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: May 26 2023, 08:09:15
 
#ifndef auto_md_h
#define auto_md_h
 
#include "matpack_data.h"
#include "matpack_sparse.h"
#include "species_tags.h"
#include "artstime.h"
#include "gas_abs_lookup.h"
#include "gridded_fields.h"
#include "linemixing_hitran.h"
#include "optproperties.h"
#include "jacobian.h"
#include "mc_antenna.h"
#include "m_general.h"
#include "parser.h"
#include "workspace_ng.h"
#include "cia.h"
#include "covariance_matrix.h"
#include "propagationmatrix.h"
#include <predefined/predef_data.h>
#include "transmissionmatrix.h"
#include "sun.h"
#include "telsem.h"
#include "tessem.h"
#include "xsec_fit.h"
#include "absorptionlines.h"
#include "linemixing.h"
#include "callback.h"
 
// This is only used for a consistency check. You can get the
// number of WSMs from md_data.nelem().
#define N_MD 2250
 
// 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,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void AbsorptionLinesCreate(// WS Generic Output:
                           AbsorptionLines& out,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void AbsorptionLinesSet(// WS Generic Output:
                        AbsorptionLines& out,
                        // WS Generic Input:
                        const AbsorptionLines& value,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void AgendaAppend(// Workspace reference:
                  Workspace& ws,
                  // WS Generic Output:
                  Agenda& out,
                  // WS Generic Output Names:
                  const String& out_wsvname,
                  // WS Generic Input:
                  const Agenda& in,
                  // WS Generic Input Names:
                  const String& in_wsvname,
                  // Agenda from controlfile:
                  const Agenda& input_agenda,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void AgendaCreate(// Workspace reference:
                  Workspace& ws,
                  // WS Generic Output:
                  Agenda& out,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void AgendaExecute(// Workspace reference:
                   Workspace& ws,
                   // WS Generic Input:
                   const Agenda& a,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void AgendaExecuteExclusive(// Workspace reference:
                            Workspace& ws,
                            // WS Generic Input:
                            const Agenda& a,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void AgendaSet(// Workspace reference:
               Workspace& ws,
               // WS Generic Output:
               Agenda& out,
               // WS Generic Output Names:
               const String& out_wsvname,
               // Agenda from controlfile:
               const Agenda& input_agenda,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void AngularGridsSetFluxCalc(// WS Output:
                             Vector& za_grid,
                             Vector& aa_grid,
                             Vector& za_grid_weights,
                             // WS Generic Input:
                             const Index& N_za_grid,
                             const Index& N_aa_grid,
                             const String& za_grid_type,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void AntennaMultiBeamsToPencilBeams(// WS Output:
                                    Matrix& sensor_pos,
                                    Matrix& sensor_los,
                                    Matrix& antenna_dlos,
                                    Index& antenna_dim,
                                    Matrix& mblock_dlos,
                                    // WS Input:
                                    const Index& atmosphere_dim,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void AntennaOff(// WS Output:
                Index& antenna_dim,
                Matrix& mblock_dlos,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void ArrayOfAbsorptionLinesCreate(// WS Generic Output:
                                  ArrayOfAbsorptionLines& out,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void ArrayOfAbsorptionLinesSet(// WS Generic Output:
                               ArrayOfAbsorptionLines& out,
                               // WS Generic Input:
                               const ArrayOfAbsorptionLines& value,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void ArrayOfAgendaAppend(// Workspace reference:
                         Workspace& ws,
                         // WS Generic Output:
                         ArrayOfAgenda& out,
                         // WS Generic Output Names:
                         const String& out_wsvname,
                         // Agenda from controlfile:
                         const Agenda& input_agenda,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfAgendaCreate(// WS Generic Output:
                         ArrayOfAgenda& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfAgendaExecute(// Workspace reference:
                          Workspace& ws,
                          // WS Input:
                          const Index& agenda_array_index,
                          // WS Generic Input:
                          const ArrayOfAgenda& agendas,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfArrayOfAbsorptionLinesCreate(// WS Generic Output:
                                         ArrayOfArrayOfAbsorptionLines& out,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void ArrayOfArrayOfAbsorptionLinesSet(// WS Generic Output:
                                      ArrayOfArrayOfAbsorptionLines& out,
                                      // WS Generic Input:
                                      const ArrayOfArrayOfAbsorptionLines& value,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void ArrayOfArrayOfGriddedField1Create(// WS Generic Output:
                                       ArrayOfArrayOfGriddedField1& out,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void ArrayOfArrayOfGriddedField1Set(// WS Generic Output:
                                    ArrayOfArrayOfGriddedField1& out,
                                    // WS Generic Input:
                                    const ArrayOfArrayOfGriddedField1& value,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void ArrayOfArrayOfGriddedField2Create(// WS Generic Output:
                                       ArrayOfArrayOfGriddedField2& out,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void ArrayOfArrayOfGriddedField2Set(// WS Generic Output:
                                    ArrayOfArrayOfGriddedField2& out,
                                    // WS Generic Input:
                                    const ArrayOfArrayOfGriddedField2& value,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void ArrayOfArrayOfGriddedField3Create(// WS Generic Output:
                                       ArrayOfArrayOfGriddedField3& out,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void ArrayOfArrayOfGriddedField3Set(// WS Generic Output:
                                    ArrayOfArrayOfGriddedField3& out,
                                    // WS Generic Input:
                                    const ArrayOfArrayOfGriddedField3& value,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void ArrayOfArrayOfIndexCreate(// WS Generic Output:
                               ArrayOfArrayOfIndex& out,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void ArrayOfArrayOfIndexSet(// WS Generic Output:
                            ArrayOfArrayOfIndex& out,
                            // WS Generic Input:
                            const ArrayOfArrayOfIndex& value,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void ArrayOfArrayOfMatrixCreate(// WS Generic Output:
                                ArrayOfArrayOfMatrix& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfArrayOfMatrixSet(// WS Generic Output:
                             ArrayOfArrayOfMatrix& out,
                             // WS Generic Input:
                             const ArrayOfArrayOfMatrix& value,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfArrayOfPropagationMatrixCreate(// WS Generic Output:
                                           ArrayOfArrayOfPropagationMatrix& out,
                                           // Verbosity object:
                                           const Verbosity& verbosity);
 
 
void ArrayOfArrayOfPropagationMatrixSet(// WS Generic Output:
                                        ArrayOfArrayOfPropagationMatrix& out,
                                        // WS Generic Input:
                                        const ArrayOfArrayOfPropagationMatrix& value,
                                        // Verbosity object:
                                        const Verbosity& verbosity);
 
 
void ArrayOfArrayOfRadiationVectorCreate(// WS Generic Output:
                                         ArrayOfArrayOfRadiationVector& out,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void ArrayOfArrayOfRadiationVectorSet(// WS Generic Output:
                                      ArrayOfArrayOfRadiationVector& out,
                                      // WS Generic Input:
                                      const ArrayOfArrayOfRadiationVector& value,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void ArrayOfArrayOfScatteringMetaDataCreate(// WS Generic Output:
                                            ArrayOfArrayOfScatteringMetaData& out,
                                            // Verbosity object:
                                            const Verbosity& verbosity);
 
 
void ArrayOfArrayOfScatteringMetaDataSet(// WS Generic Output:
                                         ArrayOfArrayOfScatteringMetaData& out,
                                         // WS Generic Input:
                                         const ArrayOfArrayOfScatteringMetaData& value,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void ArrayOfArrayOfSingleScatteringDataCreate(// WS Generic Output:
                                              ArrayOfArrayOfSingleScatteringData& out,
                                              // Verbosity object:
                                              const Verbosity& verbosity);
 
 
void ArrayOfArrayOfSingleScatteringDataSet(// WS Generic Output:
                                           ArrayOfArrayOfSingleScatteringData& out,
                                           // WS Generic Input:
                                           const ArrayOfArrayOfSingleScatteringData& value,
                                           // Verbosity object:
                                           const Verbosity& verbosity);
 
 
void ArrayOfArrayOfSpeciesTagCreate(// WS Generic Output:
                                    ArrayOfArrayOfSpeciesTag& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void ArrayOfArrayOfSpeciesTagSet(// WS Generic Output:
                                 ArrayOfArrayOfSpeciesTag& out,
                                 // WS Generic Input:
                                 const ArrayOfArrayOfSpeciesTag& value,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void ArrayOfArrayOfStokesVectorCreate(// WS Generic Output:
                                      ArrayOfArrayOfStokesVector& out,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void ArrayOfArrayOfStokesVectorSet(// WS Generic Output:
                                   ArrayOfArrayOfStokesVector& out,
                                   // WS Generic Input:
                                   const ArrayOfArrayOfStokesVector& value,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void ArrayOfArrayOfStringCreate(// WS Generic Output:
                                ArrayOfArrayOfString& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfArrayOfStringSet(// WS Generic Output:
                             ArrayOfArrayOfString& out,
                             // WS Generic Input:
                             const ArrayOfArrayOfString& value,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTensor3Create(// WS Generic Output:
                                 ArrayOfArrayOfTensor3& out,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTensor3Set(// WS Generic Output:
                              ArrayOfArrayOfTensor3& out,
                              // WS Generic Input:
                              const ArrayOfArrayOfTensor3& value,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTensor6Create(// WS Generic Output:
                                 ArrayOfArrayOfTensor6& out,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTensor6Set(// WS Generic Output:
                              ArrayOfArrayOfTensor6& out,
                              // WS Generic Input:
                              const ArrayOfArrayOfTensor6& value,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTimeCreate(// WS Generic Output:
                              ArrayOfArrayOfTime& out,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTimeSet(// WS Generic Output:
                           ArrayOfArrayOfTime& out,
                           // WS Generic Input:
                           const ArrayOfArrayOfTime& value,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTransmissionMatrixCreate(// WS Generic Output:
                                            ArrayOfArrayOfTransmissionMatrix& out,
                                            // Verbosity object:
                                            const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTransmissionMatrixSet(// WS Generic Output:
                                         ArrayOfArrayOfTransmissionMatrix& out,
                                         // WS Generic Input:
                                         const ArrayOfArrayOfTransmissionMatrix& value,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void ArrayOfArrayOfVectorCreate(// WS Generic Output:
                                ArrayOfArrayOfVector& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfArrayOfVectorSet(// WS Generic Output:
                             ArrayOfArrayOfVector& out,
                             // WS Generic Input:
                             const ArrayOfArrayOfVector& value,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfCIARecordCreate(// WS Generic Output:
                            ArrayOfCIARecord& out,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void ArrayOfCIARecordSet(// WS Generic Output:
                         ArrayOfCIARecord& out,
                         // WS Generic Input:
                         const ArrayOfCIARecord& value,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfGriddedField1Create(// WS Generic Output:
                                ArrayOfGriddedField1& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfGriddedField1Set(// WS Generic Output:
                             ArrayOfGriddedField1& out,
                             // WS Generic Input:
                             const ArrayOfGriddedField1& value,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfGriddedField2Create(// WS Generic Output:
                                ArrayOfGriddedField2& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfGriddedField2Set(// WS Generic Output:
                             ArrayOfGriddedField2& out,
                             // WS Generic Input:
                             const ArrayOfGriddedField2& value,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfGriddedField3Create(// WS Generic Output:
                                ArrayOfGriddedField3& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfGriddedField3Set(// WS Generic Output:
                             ArrayOfGriddedField3& out,
                             // WS Generic Input:
                             const ArrayOfGriddedField3& value,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfGriddedField4Create(// WS Generic Output:
                                ArrayOfGriddedField4& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfGriddedField4Set(// WS Generic Output:
                             ArrayOfGriddedField4& out,
                             // WS Generic Input:
                             const ArrayOfGriddedField4& value,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfIndexCreate(// WS Generic Output:
                        ArrayOfIndex& out,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void ArrayOfIndexLinSpace(// WS Generic Output:
                          ArrayOfIndex& out,
                          // WS Generic Input:
                          const Index& start,
                          const Index& stop,
                          const Index& step,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfIndexSet(// WS Generic Output:
                     ArrayOfIndex& out,
                     // WS Generic Input:
                     const ArrayOfIndex& value,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void ArrayOfIndexSetConstant(// WS Generic Output:
                             ArrayOfIndex& out,
                             // WS Input:
                             const Index& nelem,
                             // WS Generic Input:
                             const Index& value,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfJacobianTargetCreate(// WS Generic Output:
                                 ArrayOfJacobianTarget& out,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void ArrayOfJacobianTargetSet(// WS Generic Output:
                              ArrayOfJacobianTarget& out,
                              // WS Generic Input:
                              const ArrayOfJacobianTarget& value,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void ArrayOfMatrixCreate(// WS Generic Output:
                         ArrayOfMatrix& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfMatrixSet(// WS Generic Output:
                      ArrayOfMatrix& out,
                      // WS Generic Input:
                      const ArrayOfMatrix& value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void ArrayOfPpathCreate(// WS Generic Output:
                        ArrayOfPpath& out,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void ArrayOfPpathSet(// WS Generic Output:
                     ArrayOfPpath& out,
                     // WS Generic Input:
                     const ArrayOfPpath& value,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void ArrayOfPropagationMatrixCreate(// WS Generic Output:
                                    ArrayOfPropagationMatrix& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void ArrayOfPropagationMatrixSet(// WS Generic Output:
                                 ArrayOfPropagationMatrix& out,
                                 // WS Generic Input:
                                 const ArrayOfPropagationMatrix& value,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void ArrayOfQuantumIdentifierCreate(// WS Generic Output:
                                    ArrayOfQuantumIdentifier& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void ArrayOfQuantumIdentifierFromLines(// WS Generic Output:
                                       ArrayOfQuantumIdentifier& out,
                                       // WS Input:
                                       const ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                       // WS Generic Input:
                                       const Index& global,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void ArrayOfQuantumIdentifierSet(// WS Generic Output:
                                 ArrayOfQuantumIdentifier& out,
                                 // WS Generic Input:
                                 const ArrayOfQuantumIdentifier& value,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void ArrayOfRadiationVectorCreate(// WS Generic Output:
                                  ArrayOfRadiationVector& out,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void ArrayOfRadiationVectorSet(// WS Generic Output:
                               ArrayOfRadiationVector& out,
                               // WS Generic Input:
                               const ArrayOfRadiationVector& value,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void ArrayOfRetrievalQuantityCreate(// WS Generic Output:
                                    ArrayOfRetrievalQuantity& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void ArrayOfRetrievalQuantitySet(// WS Generic Output:
                                 ArrayOfRetrievalQuantity& out,
                                 // WS Generic Input:
                                 const ArrayOfRetrievalQuantity& value,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void ArrayOfScatteringMetaDataCreate(// WS Generic Output:
                                     ArrayOfScatteringMetaData& out,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void ArrayOfScatteringMetaDataSet(// WS Generic Output:
                                  ArrayOfScatteringMetaData& out,
                                  // WS Generic Input:
                                  const ArrayOfScatteringMetaData& value,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void ArrayOfSingleScatteringDataCreate(// WS Generic Output:
                                       ArrayOfSingleScatteringData& out,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void ArrayOfSingleScatteringDataSet(// WS Generic Output:
                                    ArrayOfSingleScatteringData& out,
                                    // WS Generic Input:
                                    const ArrayOfSingleScatteringData& value,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void ArrayOfSparseCreate(// WS Generic Output:
                         ArrayOfSparse& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfSparseSet(// WS Generic Output:
                      ArrayOfSparse& out,
                      // WS Generic Input:
                      const ArrayOfSparse& value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void ArrayOfSpeciesTagCreate(// WS Generic Output:
                             ArrayOfSpeciesTag& out,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfSpeciesTagSet(// WS Generic Output:
                          ArrayOfSpeciesTag& out,
                          // WS Generic Input:
                          const ArrayOfSpeciesTag& value,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfStokesVectorCreate(// WS Generic Output:
                               ArrayOfStokesVector& out,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void ArrayOfStokesVectorSet(// WS Generic Output:
                            ArrayOfStokesVector& out,
                            // WS Generic Input:
                            const ArrayOfStokesVector& value,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void ArrayOfStringCreate(// WS Generic Output:
                         ArrayOfString& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfStringSet(// WS Generic Output:
                      ArrayOfString& out,
                      // WS Generic Input:
                      const ArrayOfString& value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void ArrayOfSunCreate(// WS Generic Output:
                      ArrayOfSun& out,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void ArrayOfSunSet(// WS Generic Output:
                   ArrayOfSun& out,
                   // WS Generic Input:
                   const ArrayOfSun& value,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void ArrayOfTelsemAtlasCreate(// WS Generic Output:
                              ArrayOfTelsemAtlas& out,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void ArrayOfTelsemAtlasSet(// WS Generic Output:
                           ArrayOfTelsemAtlas& out,
                           // WS Generic Input:
                           const ArrayOfTelsemAtlas& value,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void ArrayOfTensor3Create(// WS Generic Output:
                          ArrayOfTensor3& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfTensor3Set(// WS Generic Output:
                       ArrayOfTensor3& out,
                       // WS Generic Input:
                       const ArrayOfTensor3& value,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void ArrayOfTensor4Create(// WS Generic Output:
                          ArrayOfTensor4& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfTensor4Set(// WS Generic Output:
                       ArrayOfTensor4& out,
                       // WS Generic Input:
                       const ArrayOfTensor4& value,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void ArrayOfTensor5Create(// WS Generic Output:
                          ArrayOfTensor5& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfTensor5Set(// WS Generic Output:
                       ArrayOfTensor5& out,
                       // WS Generic Input:
                       const ArrayOfTensor5& value,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void ArrayOfTensor6Create(// WS Generic Output:
                          ArrayOfTensor6& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfTensor6Set(// WS Generic Output:
                       ArrayOfTensor6& out,
                       // WS Generic Input:
                       const ArrayOfTensor6& value,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void ArrayOfTensor7Create(// WS Generic Output:
                          ArrayOfTensor7& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfTensor7Set(// WS Generic Output:
                       ArrayOfTensor7& out,
                       // WS Generic Input:
                       const ArrayOfTensor7& value,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void ArrayOfTimeCreate(// WS Generic Output:
                       ArrayOfTime& out,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void ArrayOfTimeNLinSpace(// WS Generic Output:
                          ArrayOfTime& out,
                          // WS Input:
                          const Index& nelem,
                          // WS Generic Input:
                          const String& start,
                          const String& stop,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfTimeSet(// WS Generic Output:
                    ArrayOfTime& out,
                    // WS Generic Input:
                    const ArrayOfTime& value,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void ArrayOfTimeSetConstant(// WS Generic Output:
                            ArrayOfTime& out,
                            // WS Input:
                            const Index& nelem,
                            // WS Generic Input:
                            const Time& value,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void ArrayOfTransmissionMatrixCreate(// WS Generic Output:
                                     ArrayOfTransmissionMatrix& out,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void ArrayOfTransmissionMatrixSet(// WS Generic Output:
                                  ArrayOfTransmissionMatrix& out,
                                  // WS Generic Input:
                                  const ArrayOfTransmissionMatrix& value,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void ArrayOfVectorCreate(// WS Generic Output:
                         ArrayOfVector& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfVectorSet(// WS Generic Output:
                      ArrayOfVector& out,
                      // WS Generic Input:
                      const ArrayOfVector& value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void ArrayOfXsecRecordCreate(// WS Generic Output:
                             ArrayOfXsecRecord& out,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfXsecRecordSet(// WS Generic Output:
                          ArrayOfXsecRecord& out,
                          // WS Generic Input:
                          const ArrayOfXsecRecord& value,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void Arts(// Workspace reference:
          Workspace& ws,
          // Agenda from controlfile:
          const Agenda& input_agenda,
          // Verbosity object:
          const Verbosity& verbosity);
 
 
void Arts2(// Workspace reference:
           Workspace& ws,
           // Agenda from controlfile:
           const Agenda& input_agenda,
           // Verbosity object:
           const Verbosity& verbosity);
 
 
void AtmFieldPRegrid(// WS Generic Output:
                     Tensor3& out,
                     // WS Generic Input:
                     const Tensor3& in,
                     const Vector& p_grid_new,
                     const Vector& p_grid_old,
                     const Index& interp_order,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void AtmFieldPRegrid(// WS Generic Output:
                     Tensor4& out,
                     // WS Generic Input:
                     const Tensor4& in,
                     const Vector& p_grid_new,
                     const Vector& p_grid_old,
                     const Index& interp_order,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void AtmFieldPerturb(// WS Generic Output:
                     Tensor3& perturbed_field,
                     // WS Input:
                     const Index& atmosphere_dim,
                     const Vector& p_grid,
                     const Vector& lat_grid,
                     const Vector& lon_grid,
                     // WS Generic Input:
                     const Tensor3& original_field,
                     const Vector& p_ret_grid,
                     const Vector& lat_ret_grid,
                     const Vector& lon_ret_grid,
                     const Index& pert_index,
                     const Numeric& pert_size,
                     const String& pert_mode,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void AtmFieldPerturbAtmGrids(// WS Generic Output:
                             Tensor3& perturbed_field,
                             // WS Input:
                             const Index& atmosphere_dim,
                             const Vector& p_grid,
                             const Vector& lat_grid,
                             const Vector& lon_grid,
                             // WS Generic Input:
                             const Tensor3& original_field,
                             const Index& pert_index,
                             const Numeric& pert_size,
                             const String& pert_mode,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void AtmFieldsAndParticleBulkPropFieldFromCompact(// WS Output:
                                                  Vector& p_grid,
                                                  Vector& lat_grid,
                                                  Vector& lon_grid,
                                                  Tensor3& t_field,
                                                  Tensor3& z_field,
                                                  Tensor4& vmr_field,
                                                  Tensor4& particle_bulkprop_field,
                                                  ArrayOfString& particle_bulkprop_names,
                                                  // WS Input:
                                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                                  const GriddedField4& atm_fields_compact,
                                                  const Index& atmosphere_dim,
                                                  // WS Generic Input:
                                                  const String& delim,
                                                  const Numeric& p_min,
                                                  const Index& check_gridnames,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);
 
 
void AtmFieldsCalc(// WS Output:
                   Tensor3& t_field,
                   Tensor3& z_field,
                   Tensor4& vmr_field,
                   EnergyLevelMap& nlte_field,
                   // WS Input:
                   const Vector& p_grid,
                   const Vector& lat_grid,
                   const Vector& lon_grid,
                   const GriddedField3& t_field_raw,
                   const GriddedField3& z_field_raw,
                   const ArrayOfGriddedField3& vmr_field_raw,
                   const ArrayOfGriddedField3& nlte_field_raw,
                   const ArrayOfQuantumIdentifier& nlte_level_identifiers,
                   const Vector& nlte_vibrational_energies,
                   const Index& atmosphere_dim,
                   // WS Generic Input:
                   const Index& interp_order,
                   const Index& vmr_zeropadding,
                   const Index& vmr_nonegative,
                   const Index& nlte_when_negative,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void AtmFieldsCalcExpand1D(// WS Output:
                           Tensor3& t_field,
                           Tensor3& z_field,
                           Tensor4& vmr_field,
                           EnergyLevelMap& nlte_field,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           const GriddedField3& t_field_raw,
                           const GriddedField3& z_field_raw,
                           const ArrayOfGriddedField3& vmr_field_raw,
                           const ArrayOfGriddedField3& nlte_field_raw,
                           const ArrayOfQuantumIdentifier& nlte_level_identifiers,
                           const Vector& nlte_vibrational_energies,
                           const Index& atmosphere_dim,
                           // WS Generic Input:
                           const Index& interp_order,
                           const Index& vmr_zeropadding,
                           const Index& vmr_nonegative,
                           const Index& nlte_when_negative,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void AtmFieldsExpand1D(// WS Output:
                       Tensor3& t_field,
                       Tensor3& z_field,
                       Tensor4& vmr_field,
                       // WS Input:
                       const Vector& p_grid,
                       const Vector& lat_grid,
                       const Vector& lon_grid,
                       const Index& atmosphere_dim,
                       // WS Generic Input:
                       const Index& chk_vmr_nan,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void AtmFieldsExtract1D(// WS Output:
                        Index& atmosphere_dim,
                        Vector& lat_grid,
                        Vector& lon_grid,
                        Tensor3& t_field,
                        Tensor3& z_field,
                        Tensor4& vmr_field,
                        // WS Generic Input:
                        const Index& ilat,
                        const Index& ilon,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void AtmFieldsRefinePgrid(// WS Output:
                          Vector& p_grid,
                          Tensor3& t_field,
                          Tensor3& z_field,
                          Tensor4& vmr_field,
                          Index& atmfields_checked,
                          Index& atmgeom_checked,
                          Index& cloudbox_checked,
                          // WS Input:
                          const Vector& lat_grid,
                          const Vector& lon_grid,
                          const Index& atmosphere_dim,
                          // WS Generic Input:
                          const Numeric& p_step,
                          const Index& interp_order,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void AtmRawRead(// WS Output:
                GriddedField3& t_field_raw,
                GriddedField3& z_field_raw,
                ArrayOfGriddedField3& vmr_field_raw,
                ArrayOfGriddedField3& nlte_field_raw,
                ArrayOfQuantumIdentifier& nlte_level_identifiers,
                Vector& nlte_vibrational_energies,
                // WS Input:
                const ArrayOfArrayOfSpeciesTag& abs_species,
                // WS Generic Input:
                const String& basename,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void AtmWithNLTERawRead(// WS Output:
                        GriddedField3& t_field_raw,
                        GriddedField3& z_field_raw,
                        ArrayOfGriddedField3& vmr_field_raw,
                        ArrayOfGriddedField3& nlte_field_raw,
                        ArrayOfQuantumIdentifier& nlte_level_identifiers,
                        Vector& nlte_vibrational_energies,
                        // WS Input:
                        const ArrayOfArrayOfSpeciesTag& abs_species,
                        // WS Generic Input:
                        const String& basename,
                        const Index& expect_vibrational_energies,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void AtmosphereSet1D(// WS Output:
                     Index& atmosphere_dim,
                     Vector& lat_grid,
                     Vector& lon_grid,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void AtmosphereSet2D(// WS Output:
                     Index& atmosphere_dim,
                     Vector& lon_grid,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void AtmosphereSet3D(// WS Output:
                     Index& atmosphere_dim,
                     Vector& lat_true,
                     Vector& lon_true,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CIAInfo(// WS Generic Input:
             const String& catalogpath,
             const ArrayOfString& cia_tags,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void CIARecordCreate(// WS Generic Output:
                     CIARecord& out,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CIARecordReadFromFile(// WS Generic Output:
                           CIARecord& cia_record,
                           // WS Generic Input:
                           const String& species_tag,
                           const String& filename,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void CIARecordSet(// WS Generic Output:
                  CIARecord& out,
                  // WS Generic Input:
                  const CIARecord& value,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void CallbackFunctionCreate(// WS Generic Output:
                            CallbackFunction& out,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void CallbackFunctionExecute(// Workspace reference:
                             Workspace& ws,
                             // WS Generic Input:
                             const CallbackFunction& function,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void CallbackFunctionSet(// WS Generic Output:
                         CallbackFunction& out,
                         // WS Generic Input:
                         const CallbackFunction& value,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void CheckUnique(// WS Input:
                 const ArrayOfAbsorptionLines& abs_lines,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Numeric& var1,
             const Numeric& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Vector& var1,
             const Vector& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Matrix& var1,
             const Matrix& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Tensor3& var1,
             const Tensor3& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Tensor4& var1,
             const Tensor4& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Tensor5& var1,
             const Tensor5& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Tensor7& var1,
             const Tensor7& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const ArrayOfVector& var1,
             const ArrayOfVector& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const ArrayOfMatrix& var1,
             const ArrayOfMatrix& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const ArrayOfTensor7& var1,
             const ArrayOfTensor7& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const GriddedField3& var1,
             const GriddedField3& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Sparse& var1,
             const Sparse& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const SingleScatteringData& var1,
             const SingleScatteringData& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Numeric& var1,
                     const Numeric& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Vector& var1,
                     const Vector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Matrix& var1,
                     const Matrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Tensor3& var1,
                     const Tensor3& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Tensor4& var1,
                     const Tensor4& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Tensor5& var1,
                     const Tensor5& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Tensor6& var1,
                     const Tensor6& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Tensor7& var1,
                     const Tensor7& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfVector& var1,
                     const ArrayOfVector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfMatrix& var1,
                     const ArrayOfMatrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfTensor3& var1,
                     const ArrayOfTensor3& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfTensor4& var1,
                     const ArrayOfTensor4& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfTensor6& var1,
                     const ArrayOfTensor6& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfTensor7& var1,
                     const ArrayOfTensor7& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfVector& var1,
                     const ArrayOfArrayOfVector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfMatrix& var1,
                     const ArrayOfArrayOfMatrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfTensor3& var1,
                     const ArrayOfArrayOfTensor3& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfTensor6& var1,
                     const ArrayOfArrayOfTensor6& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfPropagationMatrix& var1,
                     const ArrayOfPropagationMatrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfPropagationMatrix& var1,
                     const ArrayOfArrayOfPropagationMatrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfStokesVector& var1,
                     const ArrayOfStokesVector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfStokesVector& var1,
                     const ArrayOfArrayOfStokesVector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const EnergyLevelMap& var1,
                     const EnergyLevelMap& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const PropagationMatrix& var1,
                     const PropagationMatrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const StokesVector& var1,
                     const StokesVector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CovarianceMatrixCreate(// WS Generic Output:
                            CovarianceMatrix& out,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void CovarianceMatrixSet(// WS Generic Output:
                         CovarianceMatrix& out,
                         // WS Generic Input:
                         const CovarianceMatrix& value,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void DOAngularGridsSet(// WS Output:
                       Index& doit_za_grid_size,
                       Vector& aa_grid,
                       Vector& za_grid,
                       // WS Generic Input:
                       const Index& N_za_grid,
                       const Index& N_aa_grid,
                       const String& za_grid_opt_file,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void DOBatchCalc(// Workspace reference:
                 Workspace& ws,
                 // WS Output:
                 ArrayOfTensor7& dobatch_cloudbox_field,
                 ArrayOfTensor5& dobatch_radiance_field,
                 ArrayOfTensor4& dobatch_irradiance_field,
                 ArrayOfTensor5& dobatch_spectral_irradiance_field,
                 // WS Input:
                 const Index& ybatch_start,
                 const Index& ybatch_n,
                 const Agenda& dobatch_calc_agenda,
                 // WS Generic Input:
                 const Index& robust,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void DiagonalMatrix(// WS Generic Output:
                    Matrix& out,
                    // WS Generic Input:
                    const Vector& v,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void DiagonalMatrix(// WS Generic Output:
                    Sparse& out,
                    // WS Generic Input:
                    const Vector& v,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void DisortCalc(// Workspace reference:
                Workspace& ws,
                // WS Output:
                Tensor7& cloudbox_field,
                ArrayOfMatrix& disort_aux,
                // WS Input:
                const Index& atmfields_checked,
                const Index& atmgeom_checked,
                const Index& scat_data_checked,
                const Index& cloudbox_checked,
                const Index& cloudbox_on,
                const ArrayOfIndex& cloudbox_limits,
                const Agenda& propmat_clearsky_agenda,
                const Agenda& gas_scattering_agenda,
                const Index& atmosphere_dim,
                const Tensor4& pnd_field,
                const Tensor3& t_field,
                const Tensor3& z_field,
                const Tensor4& vmr_field,
                const Vector& p_grid,
                const Vector& lat_true,
                const Vector& lon_true,
                const Vector& refellipsoid,
                const ArrayOfArrayOfSingleScatteringData& scat_data,
                const ArrayOfSun& suns,
                const Vector& f_grid,
                const Vector& za_grid,
                const Vector& aa_grid,
                const Index& stokes_dim,
                const Matrix& z_surface,
                const Numeric& surface_skin_t,
                const Vector& surface_scalar_reflectivity,
                const Index& gas_scattering_do,
                const Index& suns_do,
                const ArrayOfString& disort_aux_vars,
                // WS Generic Input:
                const Index& nstreams,
                const Index& Npfct,
                const Index& only_tro,
                const Index& quiet,
                const Index& emission,
                const Index& intensity_correction,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void DisortCalcClearsky(// Workspace reference:
                        Workspace& ws,
                        // WS Output:
                        Tensor7& spectral_radiance_field,
                        ArrayOfMatrix& disort_aux,
                        // WS Input:
                        const Index& atmfields_checked,
                        const Index& atmgeom_checked,
                        const Agenda& propmat_clearsky_agenda,
                        const Agenda& gas_scattering_agenda,
                        const Index& atmosphere_dim,
                        const Tensor3& t_field,
                        const Tensor3& z_field,
                        const Tensor4& vmr_field,
                        const Vector& p_grid,
                        const Vector& lat_true,
                        const Vector& lon_true,
                        const Vector& refellipsoid,
                        const ArrayOfSun& suns,
                        const Vector& f_grid,
                        const Vector& za_grid,
                        const Vector& aa_grid,
                        const Index& stokes_dim,
                        const Matrix& z_surface,
                        const Numeric& surface_skin_t,
                        const Vector& surface_scalar_reflectivity,
                        const Index& gas_scattering_do,
                        const Index& suns_do,
                        const ArrayOfString& disort_aux_vars,
                        // WS Generic Input:
                        const Index& nstreams,
                        const Index& quiet,
                        const Index& emission,
                        const Index& intensity_correction,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void DisortCalcIrradiance(// Workspace reference:
                          Workspace& ws,
                          // WS Output:
                          Tensor5& spectral_irradiance_field,
                          ArrayOfMatrix& disort_aux,
                          // WS Input:
                          const Index& atmfields_checked,
                          const Index& atmgeom_checked,
                          const Index& scat_data_checked,
                          const Agenda& propmat_clearsky_agenda,
                          const Agenda& gas_scattering_agenda,
                          const Index& atmosphere_dim,
                          const Tensor4& pnd_field,
                          const Tensor3& t_field,
                          const Tensor3& z_field,
                          const Tensor4& vmr_field,
                          const Vector& p_grid,
                          const Vector& lat_true,
                          const Vector& lon_true,
                          const Vector& refellipsoid,
                          const ArrayOfArrayOfSingleScatteringData& scat_data,
                          const ArrayOfSun& suns,
                          const Vector& f_grid,
                          const Index& stokes_dim,
                          const Matrix& z_surface,
                          const Numeric& surface_skin_t,
                          const Vector& surface_scalar_reflectivity,
                          const Index& gas_scattering_do,
                          const Index& suns_do,
                          const ArrayOfString& disort_aux_vars,
                          // WS Generic Input:
                          const Index& nstreams,
                          const Index& Npfct,
                          const Index& only_tro,
                          const Index& quiet,
                          const Index& emission,
                          const Index& intensity_correction,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void DisortCalcWithARTSSurface(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               Tensor7& cloudbox_field,
                               ArrayOfMatrix& disort_aux,
                               // WS Input:
                               const Index& atmfields_checked,
                               const Index& atmgeom_checked,
                               const Index& scat_data_checked,
                               const Index& cloudbox_checked,
                               const Index& cloudbox_on,
                               const ArrayOfIndex& cloudbox_limits,
                               const Agenda& propmat_clearsky_agenda,
                               const Agenda& surface_rtprop_agenda,
                               const Agenda& gas_scattering_agenda,
                               const Index& atmosphere_dim,
                               const Tensor4& pnd_field,
                               const Tensor3& t_field,
                               const Tensor3& z_field,
                               const Tensor4& vmr_field,
                               const Vector& p_grid,
                               const Vector& lat_true,
                               const Vector& lon_true,
                               const Vector& refellipsoid,
                               const ArrayOfArrayOfSingleScatteringData& scat_data,
                               const ArrayOfSun& suns,
                               const Vector& f_grid,
                               const Vector& za_grid,
                               const Vector& aa_grid,
                               const Index& stokes_dim,
                               const Matrix& z_surface,
                               const Index& gas_scattering_do,
                               const Index& suns_do,
                               const ArrayOfString& disort_aux_vars,
                               // WS Generic Input:
                               const Index& nstreams,
                               const Index& Npfct,
                               const Index& only_tro,
                               const Index& quiet,
                               const Index& emission,
                               const Index& intensity_correction,
                               const Numeric& inc_angle,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void DoitCalc(// Workspace reference:
              Workspace& ws,
              // WS Output:
              Tensor7& cloudbox_field,
              // WS Input:
              const Index& atmfields_checked,
              const Index& atmgeom_checked,
              const Index& cloudbox_checked,
              const Index& scat_data_checked,
              const Index& cloudbox_on,
              const Vector& f_grid,
              const Agenda& doit_mono_agenda,
              const Index& doit_is_initialized,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void DoitGetIncoming(// Workspace reference:
                     Workspace& ws,
                     // WS Output:
                     Tensor7& cloudbox_field,
                     // WS Input:
                     const Index& atmfields_checked,
                     const Index& atmgeom_checked,
                     const Index& cloudbox_checked,
                     const Index& doit_is_initialized,
                     const Agenda& iy_main_agenda,
                     const Index& atmosphere_dim,
                     const Vector& lat_grid,
                     const Vector& lon_grid,
                     const Tensor3& z_field,
                     const EnergyLevelMap& nlte_field,
                     const Index& cloudbox_on,
                     const ArrayOfIndex& cloudbox_limits,
                     const Vector& f_grid,
                     const Index& stokes_dim,
                     const Vector& za_grid,
                     const Vector& aa_grid,
                     // WS Generic Input:
                     const Index& rigorous,
                     const Numeric& maxratio,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void DoitGetIncoming1DAtm(// Workspace reference:
                          Workspace& ws,
                          // WS Output:
                          Tensor7& cloudbox_field,
                          Index& cloudbox_on,
                          // WS Input:
                          const Index& atmfields_checked,
                          const Index& atmgeom_checked,
                          const Index& cloudbox_checked,
                          const Index& doit_is_initialized,
                          const Agenda& iy_main_agenda,
                          const Index& atmosphere_dim,
                          const Vector& lat_grid,
                          const Vector& lon_grid,
                          const Tensor3& z_field,
                          const EnergyLevelMap& nlte_field,
                          const ArrayOfIndex& cloudbox_limits,
                          const Vector& f_grid,
                          const Index& stokes_dim,
                          const Vector& za_grid,
                          const Vector& aa_grid,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void DoitInit(// WS Output:
              Tensor6& doit_scat_field,
              Tensor7& cloudbox_field,
              Index& doit_is_initialized,
              // WS Input:
              const Index& stokes_dim,
              const Index& atmosphere_dim,
              const Vector& f_grid,
              const Vector& za_grid,
              const Vector& aa_grid,
              const Index& doit_za_grid_size,
              const Index& cloudbox_on,
              const ArrayOfIndex& cloudbox_limits,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void DoitScatteringDataPrepare(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               ArrayOfTensor7& pha_mat_sptDOITOpt,
                               ArrayOfArrayOfSingleScatteringData& scat_data_mono,
                               Tensor7& pha_mat_doit,
                               Vector& aa_grid,
                               // WS Input:
                               const Index& doit_za_grid_size,
                               const ArrayOfArrayOfSingleScatteringData& scat_data,
                               const Index& scat_data_checked,
                               const Index& f_index,
                               const Index& atmosphere_dim,
                               const Index& stokes_dim,
                               const Tensor3& t_field,
                               const ArrayOfIndex& cloudbox_limits,
                               const Tensor4& pnd_field,
                               const Agenda& pha_mat_spt_agenda,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void DoitWriteIterationFields(// WS Input:
                              const Index& doit_iteration_counter,
                              const Tensor6& cloudbox_field_mono,
                              const Index& f_index,
                              // WS Generic Input:
                              const ArrayOfIndex& iterations,
                              const ArrayOfIndex& frequencies,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void Duration(// WS Generic Output:
              Numeric& duration,
              // WS Generic Input:
              const Time& start,
              const Time& end,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void EnergyLevelMapCreate(// WS Generic Output:
                          EnergyLevelMap& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void EnergyLevelMapSet(// WS Generic Output:
                       EnergyLevelMap& out,
                       // WS Generic Input:
                       const EnergyLevelMap& value,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void Error(// WS Generic Input:
           const String& msg,
           // Verbosity object:
           const Verbosity& verbosity);
 
 
void Exit(// Verbosity object:
          const Verbosity& verbosity);
 
 
void ExtractFromMetaSingleScatSpecies(// WS Generic Output:
                                      Vector& meta_param,
                                      // WS Input:
                                      const ArrayOfArrayOfScatteringMetaData& scat_meta,
                                      // WS Generic Input:
                                      const String& meta_name,
                                      const Index& scat_species_index,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void FastemStandAlone(// WS Generic Output:
                      Matrix& emissivity,
                      Matrix& reflectivity,
                      // WS Input:
                      const Vector& f_grid,
                      const Numeric& surface_skin_t,
                      // WS Generic Input:
                      const Numeric& za,
                      const Numeric& salinity,
                      const Numeric& wind_speed,
                      const Numeric& rel_aa,
                      const Vector& transmittance,
                      const Index& fastem_version,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void FieldFromGriddedField(// WS Generic Output:
                           Matrix& out,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           // WS Generic Input:
                           const GriddedField2& in,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void FieldFromGriddedField(// WS Generic Output:
                           Tensor3& out,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           // WS Generic Input:
                           const GriddedField3& in,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void FieldFromGriddedField(// WS Generic Output:
                           Tensor4& out,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           // WS Generic Input:
                           const GriddedField4& in,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void FieldFromGriddedField(// WS Generic Output:
                           Tensor4& out,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           // WS Generic Input:
                           const ArrayOfGriddedField3& in,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void FlagOff(// WS Generic Output:
             Index& flag,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void FlagOn(// WS Generic Output:
            Index& flag,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             ArrayOfTime& out,
             // WS Generic Input:
             const ArrayOfArrayOfTime& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             ArrayOfVector& out,
             // WS Generic Input:
             const ArrayOfArrayOfVector& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             Matrix& out,
             // WS Generic Input:
             const ArrayOfVector& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             Tensor3& out,
             // WS Generic Input:
             const ArrayOfMatrix& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             Tensor4& out,
             // WS Generic Input:
             const ArrayOfTensor3& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             Tensor5& out,
             // WS Generic Input:
             const ArrayOfTensor4& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             Tensor6& out,
             // WS Generic Input:
             const ArrayOfTensor5& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             Tensor7& out,
             // WS Generic Input:
             const ArrayOfTensor6& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void ForLoop(// Workspace reference:
             Workspace& ws,
             // WS Input:
             const Agenda& forloop_agenda,
             // WS Generic Input:
             const Index& start,
             const Index& stop,
             const Index& step,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void FrequencyFromCGSAngularWavenumber(// WS Generic Output:
                                       Numeric& frequency,
                                       // WS Generic Input:
                                       const Numeric& angular_wavenumber,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void FrequencyFromCGSAngularWavenumber(// WS Generic Output:
                                       Vector& frequency,
                                       // WS Generic Input:
                                       const Vector& angular_wavenumber,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void FrequencyFromCGSKayserWavenumber(// WS Generic Output:
                                      Numeric& frequency,
                                      // WS Generic Input:
                                      const Numeric& kayser_wavenumber,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void FrequencyFromCGSKayserWavenumber(// WS Generic Output:
                                      Vector& frequency,
                                      // WS Generic Input:
                                      const Vector& kayser_wavenumber,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void FrequencyFromWavelength(// WS Generic Output:
                             Numeric& frequency,
                             // WS Generic Input:
                             const Numeric& wavelength,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void FrequencyFromWavelength(// WS Generic Output:
                             Vector& frequency,
                             // WS Generic Input:
                             const Vector& wavelength,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void GasAbsLookupCreate(// WS Generic Output:
                        GasAbsLookup& out,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void GasAbsLookupSet(// WS Generic Output:
                     GasAbsLookup& out,
                     // WS Generic Input:
                     const GasAbsLookup& value,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void GetEnvironmentVariable(// WS Generic Output:
                            String& out,
                            // WS Generic Input:
                            const String& in,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void GetEnvironmentVariable(// WS Generic Output:
                            Index& out,
                            // WS Generic Input:
                            const String& in,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void GetNumberOfThreads(// WS Generic Output:
                        Index& nthreads,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void GridPosCreate(// WS Generic Output:
                   GridPos& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void GridPosSet(// WS Generic Output:
                GridPos& out,
                // WS Generic Input:
                const GridPos& value,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void GriddedField1Create(// WS Generic Output:
                         GriddedField1& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedField1Set(// WS Generic Output:
                      GriddedField1& out,
                      // WS Generic Input:
                      const GriddedField1& value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void GriddedField2Create(// WS Generic Output:
                         GriddedField2& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedField2Set(// WS Generic Output:
                      GriddedField2& out,
                      // WS Generic Input:
                      const GriddedField2& value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void GriddedField3Create(// WS Generic Output:
                         GriddedField3& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedField3Set(// WS Generic Output:
                      GriddedField3& out,
                      // WS Generic Input:
                      const GriddedField3& value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void GriddedField4Create(// WS Generic Output:
                         GriddedField4& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedField4Set(// WS Generic Output:
                      GriddedField4& out,
                      // WS Generic Input:
                      const GriddedField4& value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void GriddedField5Create(// WS Generic Output:
                         GriddedField5& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedField5Set(// WS Generic Output:
                      GriddedField5& out,
                      // WS Generic Input:
                      const GriddedField5& value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void GriddedField6Create(// WS Generic Output:
                         GriddedField6& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedField6Set(// WS Generic Output:
                      GriddedField6& out,
                      // WS Generic Input:
                      const GriddedField6& value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void GriddedFieldLatLonExpand(// WS Generic Output:
                              GriddedField2& out,
                              // WS Generic Input:
                              const GriddedField2& in,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldLatLonExpand(// WS Generic Output:
                              GriddedField3& out,
                              // WS Generic Input:
                              const GriddedField3& in,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldLatLonExpand(// WS Generic Output:
                              GriddedField4& out,
                              // WS Generic Input:
                              const GriddedField4& in,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldLatLonExpand(// WS Generic Output:
                              ArrayOfGriddedField3& out,
                              // WS Generic Input:
                              const ArrayOfGriddedField3& in,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldLatLonRegrid(// WS Generic Output:
                              GriddedField2& out,
                              // WS Input:
                              const Vector& lat_true,
                              const Vector& lon_true,
                              // WS Generic Input:
                              const GriddedField2& in,
                              const Index& interp_order,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldLatLonRegrid(// WS Generic Output:
                              GriddedField3& out,
                              // WS Input:
                              const Vector& lat_true,
                              const Vector& lon_true,
                              // WS Generic Input:
                              const GriddedField3& in,
                              const Index& interp_order,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldLatLonRegrid(// WS Generic Output:
                              GriddedField4& out,
                              // WS Input:
                              const Vector& lat_true,
                              const Vector& lon_true,
                              // WS Generic Input:
                              const GriddedField4& in,
                              const Index& interp_order,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldLatLonRegrid(// WS Generic Output:
                              ArrayOfGriddedField3& out,
                              // WS Input:
                              const Vector& lat_true,
                              const Vector& lon_true,
                              // WS Generic Input:
                              const ArrayOfGriddedField3& in,
                              const Index& interp_order,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldPRegrid(// WS Generic Output:
                         GriddedField3& out,
                         // WS Input:
                         const Vector& p_grid,
                         // WS Generic Input:
                         const GriddedField3& in,
                         const Index& interp_order,
                         const Index& zeropadding,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedFieldPRegrid(// WS Generic Output:
                         GriddedField4& out,
                         // WS Input:
                         const Vector& p_grid,
                         // WS Generic Input:
                         const GriddedField4& in,
                         const Index& interp_order,
                         const Index& zeropadding,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedFieldPRegrid(// WS Generic Output:
                         ArrayOfGriddedField3& out,
                         // WS Input:
                         const Vector& p_grid,
                         // WS Generic Input:
                         const ArrayOfGriddedField3& in,
                         const Index& interp_order,
                         const Index& zeropadding,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedFieldZToPRegrid(// WS Generic Output:
                            GriddedField3& out,
                            // WS Input:
                            const Vector& p_grid,
                            const Vector& lat_grid,
                            const Vector& lon_grid,
                            const Tensor3& z_field,
                            // WS Generic Input:
                            const GriddedField3& in,
                            const Index& interp_order,
                            const Index& zeropadding,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void HitranRelaxationMatrixDataCreate(// WS Generic Output:
                                      HitranRelaxationMatrixData& out,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void HitranRelaxationMatrixDataSet(// WS Generic Output:
                                   HitranRelaxationMatrixData& out,
                                   // WS Generic Input:
                                   const HitranRelaxationMatrixData& value,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void HydrotableCalc(// Workspace reference:
                    Workspace& ws,
                    // WS Generic Output:
                    GriddedField4& hydrotable,
                    // WS Input:
                    const ArrayOfAgenda& pnd_agenda_array,
                    const ArrayOfArrayOfString& pnd_agenda_array_input_names,
                    const ArrayOfArrayOfSingleScatteringData& scat_data,
                    const Index& scat_data_checked,
                    const Vector& f_grid,
                    // WS Generic Input:
                    const Index& iss,
                    const Vector& T_grid,
                    const Vector& wc_grid,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void INCLUDE(// Verbosity object:
             const Verbosity& verbosity);
 
 
void IndexAdd(// WS Generic Output:
              Index& out,
              // WS Generic Input:
              const Index& in,
              const Index& value,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void IndexCreate(// WS Generic Output:
                 Index& out,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void IndexDivide(// WS Generic Output:
                 Index& out,
                 // WS Generic Input:
                 const Index& in,
                 const Index& value,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void IndexMultiply(// WS Generic Output:
                   Index& out,
                   // WS Generic Input:
                   const Index& in,
                   const Index& value,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void IndexNumberOfAtmosphericPoints(// WS Generic Output:
                                    Index& n,
                                    // WS Input:
                                    const Index& atmosphere_dim,
                                    const Vector& p_grid,
                                    const Vector& lat_grid,
                                    const Vector& lon_grid,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void IndexSet(// WS Generic Output:
              Index& out,
              // WS Generic Input:
              const Index& value,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void IndexStepDown(// WS Generic Output:
                   Index& out,
                   // WS Generic Input:
                   const Index& in,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void IndexStepUp(// WS Generic Output:
                 Index& out,
                 // WS Generic Input:
                 const Index& in,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void IndexSubtract(// WS Generic Output:
                   Index& out,
                   // WS Generic Input:
                   const Index& in,
                   const Index& value,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void InterpAtmFieldToPosition(// WS Generic Output:
                              Numeric& out,
                              // WS Input:
                              const Index& atmosphere_dim,
                              const Vector& p_grid,
                              const Vector& lat_grid,
                              const Vector& lon_grid,
                              const Tensor3& z_field,
                              const Vector& rtp_pos,
                              // WS Generic Input:
                              const Tensor3& field,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void InterpGriddedField2ToPosition(// WS Generic Output:
                                   Numeric& out,
                                   // WS Input:
                                   const Index& atmosphere_dim,
                                   const Vector& lat_grid,
                                   const Vector& lat_true,
                                   const Vector& lon_true,
                                   const Vector& rtp_pos,
                                   // WS Generic Input:
                                   const GriddedField2& gfield2,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void InterpSurfaceFieldToPosition(// WS Generic Output:
                                  Numeric& out,
                                  // WS Input:
                                  const Index& atmosphere_dim,
                                  const Vector& lat_grid,
                                  const Vector& lon_grid,
                                  const Vector& rtp_pos,
                                  const Matrix& z_surface,
                                  // WS Generic Input:
                                  const Matrix& field,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void InterpSurfaceTypeMask(// WS Generic Output:
                           Index& surface_type,
                           // WS Input:
                           const Index& atmosphere_dim,
                           const Vector& lat_grid,
                           const Vector& lat_true,
                           const Vector& lon_true,
                           const Vector& rtp_pos,
                           const GriddedField2& surface_type_mask,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void IntersectionGeometricalWithAltitude(// WS Generic Output:
                                         Matrix& pos,
                                         Matrix& los,
                                         // WS Input:
                                         const Matrix& sensor_pos,
                                         const Matrix& sensor_los,
                                         const Vector& refellipsoid,
                                         const Vector& lat_grid,
                                         const Vector& lon_grid,
                                         // WS Generic Input:
                                         const Numeric& altitude,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void JacobianTargetCreate(// WS Generic Output:
                          JacobianTarget& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void JacobianTargetSet(// WS Generic Output:
                       JacobianTarget& out,
                       // WS Generic Input:
                       const JacobianTarget& value,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void LocalTimeOffset(// WS Generic Output:
                     Numeric& dt,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void MCAntennaCreate(// WS Generic Output:
                     MCAntenna& out,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void MCAntennaSet(// WS Generic Output:
                  MCAntenna& out,
                  // WS Generic Input:
                  const MCAntenna& value,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void MCGeneral(// Workspace reference:
               Workspace& ws,
               // WS Output:
               Vector& y,
               Index& mc_iteration_count,
               Vector& mc_error,
               Tensor3& mc_points,
               ArrayOfIndex& mc_source_domain,
               ArrayOfIndex& mc_scat_order,
               // WS Input:
               const MCAntenna& mc_antenna,
               const Vector& f_grid,
               const Index& f_index,
               const Matrix& sensor_pos,
               const Matrix& sensor_los,
               const Index& stokes_dim,
               const Index& atmosphere_dim,
               const Agenda& ppath_step_agenda,
               const Numeric& ppath_lmax,
               const Numeric& ppath_lraytrace,
               const Agenda& iy_space_agenda,
               const Agenda& surface_rtprop_agenda,
               const Agenda& propmat_clearsky_agenda,
               const Vector& p_grid,
               const Vector& lat_grid,
               const Vector& lon_grid,
               const Tensor3& z_field,
               const Vector& refellipsoid,
               const Matrix& z_surface,
               const Tensor3& t_field,
               const Tensor4& vmr_field,
               const Index& cloudbox_on,
               const ArrayOfIndex& cloudbox_limits,
               const Tensor4& pnd_field,
               const ArrayOfArrayOfSingleScatteringData& scat_data,
               const Index& atmfields_checked,
               const Index& atmgeom_checked,
               const Index& scat_data_checked,
               const Index& cloudbox_checked,
               const String& iy_unit,
               const Index& mc_seed,
               const Numeric& mc_std_err,
               const Index& mc_max_time,
               const Index& mc_max_iter,
               const Index& mc_min_iter,
               const Numeric& mc_taustep_limit,
               // WS Generic Input:
               const Index& l_mc_scat_order,
               const Index& t_interp_order,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void MCRadar(// Workspace reference:
             Workspace& ws,
             // WS Output:
             Vector& y,
             Vector& mc_error,
             // WS Input:
             const MCAntenna& mc_antenna,
             const Vector& f_grid,
             const Index& f_index,
             const Matrix& sensor_pos,
             const Matrix& sensor_los,
             const Index& stokes_dim,
             const Index& atmosphere_dim,
             const Numeric& ppath_lmax,
             const Agenda& ppath_step_agenda,
             const Numeric& ppath_lraytrace,
             const Agenda& propmat_clearsky_agenda,
             const Vector& p_grid,
             const Vector& lat_grid,
             const Vector& lon_grid,
             const Tensor3& z_field,
             const Vector& refellipsoid,
             const Matrix& z_surface,
             const Tensor3& t_field,
             const Tensor4& vmr_field,
             const Index& cloudbox_on,
             const ArrayOfIndex& cloudbox_limits,
             const Tensor4& pnd_field,
             const ArrayOfArrayOfSingleScatteringData& scat_data,
             const Vector& mc_y_tx,
             const Vector& range_bins,
             const Index& atmfields_checked,
             const Index& atmgeom_checked,
             const Index& scat_data_checked,
             const Index& cloudbox_checked,
             const String& iy_unit_radar,
             const Index& mc_max_scatorder,
             const Index& mc_seed,
             const Index& mc_max_iter,
             // WS Generic Input:
             const Numeric& ze_tref,
             const Numeric& k2,
             const Index& t_interp_order,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void MCSetSeedFromTime(// WS Output:
                       Index& mc_seed,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void MagFieldsCalc(// WS Output:
                   Tensor3& mag_u_field,
                   Tensor3& mag_v_field,
                   Tensor3& mag_w_field,
                   // WS Input:
                   const Vector& p_grid,
                   const Vector& lat_grid,
                   const Vector& lon_grid,
                   const GriddedField3& mag_u_field_raw,
                   const GriddedField3& mag_v_field_raw,
                   const GriddedField3& mag_w_field_raw,
                   const Index& atmosphere_dim,
                   // WS Generic Input:
                   const Index& interp_order,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void MagFieldsCalcExpand1D(// WS Output:
                           Tensor3& mag_u_field,
                           Tensor3& mag_v_field,
                           Tensor3& mag_w_field,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           const GriddedField3& mag_u_field_raw,
                           const GriddedField3& mag_v_field_raw,
                           const GriddedField3& mag_w_field_raw,
                           const Index& atmosphere_dim,
                           // WS Generic Input:
                           const Index& interp_order,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void MagFieldsCalcIGRF(// WS Output:
                       Tensor3& mag_u_field,
                       Tensor3& mag_v_field,
                       Tensor3& mag_w_field,
                       // WS Input:
                       const Tensor3& z_field,
                       const Vector& lat_grid,
                       const Vector& lon_grid,
                       const Vector& refellipsoid,
                       const Time& time,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void MagFieldsFromAltitudeRawCalc(// WS Output:
                                  Tensor3& mag_u_field,
                                  Tensor3& mag_v_field,
                                  Tensor3& mag_w_field,
                                  // WS Input:
                                  const Vector& lat_grid,
                                  const Vector& lon_grid,
                                  const Tensor3& z_field,
                                  const GriddedField3& mag_u_field_raw,
                                  const GriddedField3& mag_v_field_raw,
                                  const GriddedField3& mag_w_field_raw,
                                  // WS Generic Input:
                                  const Index& interp_order,
                                  const Numeric& extrapolating,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void MagRawRead(// WS Output:
                GriddedField3& mag_u_field_raw,
                GriddedField3& mag_v_field_raw,
                GriddedField3& mag_w_field_raw,
                // WS Generic Input:
                const String& basename,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void MapOfErrorCorrectedSuddenDataCreate(// WS Generic Output:
                                         MapOfErrorCorrectedSuddenData& out,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void MapOfErrorCorrectedSuddenDataSet(// WS Generic Output:
                                      MapOfErrorCorrectedSuddenData& out,
                                      // WS Generic Input:
                                      const MapOfErrorCorrectedSuddenData& value,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void Matrix1ColFromVector(// WS Generic Output:
                          Matrix& out,
                          // WS Generic Input:
                          const Vector& v,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void Matrix1RowFromVector(// WS Generic Output:
                          Matrix& out,
                          // WS Generic Input:
                          const Vector& v,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void Matrix2ColFromVectors(// WS Generic Output:
                           Matrix& out,
                           // WS Generic Input:
                           const Vector& v1,
                           const Vector& v2,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void Matrix2RowFromVectors(// WS Generic Output:
                           Matrix& out,
                           // WS Generic Input:
                           const Vector& v1,
                           const Vector& v2,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void Matrix3ColFromVectors(// WS Generic Output:
                           Matrix& out,
                           // WS Generic Input:
                           const Vector& v1,
                           const Vector& v2,
                           const Vector& v3,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void Matrix3RowFromVectors(// WS Generic Output:
                           Matrix& out,
                           // WS Generic Input:
                           const Vector& v1,
                           const Vector& v2,
                           const Vector& v3,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void MatrixAdd(// WS Generic Output:
               Matrix& out,
               // WS Generic Input:
               const Matrix& in,
               const Numeric& value,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void MatrixCBR(// WS Generic Output:
               Matrix& out,
               // WS Input:
               const Index& stokes_dim,
               // WS Generic Input:
               const Vector& f,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void MatrixCopySparse(// WS Generic Output:
                      Matrix& out,
                      // WS Generic Input:
                      const Sparse& in,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void MatrixCreate(// WS Generic Output:
                  Matrix& out,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void MatrixDivide(// WS Generic Output:
                  Matrix& out,
                  // WS Generic Input:
                  const Matrix& in,
                  const Numeric& value,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void MatrixExtractFromTensor3(// WS Generic Output:
                              Matrix& out,
                              // WS Generic Input:
                              const Tensor3& in,
                              const Index& i,
                              const String& direction,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void MatrixFromCovarianceMatrix(// WS Generic Output:
                                Matrix& out,
                                // WS Generic Input:
                                const CovarianceMatrix& in,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void MatrixGaussian(// WS Generic Output:
                    Matrix& Y,
                    // WS Generic Input:
                    const Vector& x_row,
                    const Numeric& x0_row,
                    const Numeric& si_row,
                    const Numeric& fwhm_row,
                    const Vector& x_col,
                    const Numeric& x0_col,
                    const Numeric& si_col,
                    const Numeric& fwhm_col,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void MatrixIdentity(// WS Generic Output:
                    Matrix& out,
                    // WS Generic Input:
                    const Index& n,
                    const Numeric& value,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void MatrixMatrixMultiply(// WS Generic Output:
                          Matrix& Y,
                          // WS Generic Input:
                          const Matrix& M,
                          const Matrix& X,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void MatrixMultiply(// WS Generic Output:
                    Matrix& out,
                    // WS Generic Input:
                    const Matrix& in,
                    const Numeric& value,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void MatrixPlanck(// WS Generic Output:
                  Matrix& out,
                  // WS Input:
                  const Index& stokes_dim,
                  // WS Generic Input:
                  const Vector& f,
                  const Numeric& t,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void MatrixReshapeTensor3(// WS Generic Output:
                          Matrix& out,
                          // WS Generic Input:
                          const Tensor3& in,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void MatrixSet(// WS Generic Output:
               Matrix& out,
               // WS Generic Input:
               const Matrix& value,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void MatrixSetConstant(// WS Generic Output:
                       Matrix& out,
                       // WS Input:
                       const Index& nrows,
                       const Index& ncols,
                       // WS Generic Input:
                       const Numeric& value,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void MatrixSubtract(// WS Generic Output:
                    Matrix& out,
                    // WS Generic Input:
                    const Matrix& in,
                    const Numeric& value,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void MatrixUnitIntensity(// WS Generic Output:
                         Matrix& out,
                         // WS Input:
                         const Index& stokes_dim,
                         // WS Generic Input:
                         const Vector& f,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void NumericAdd(// WS Generic Output:
                Numeric& out,
                // WS Generic Input:
                const Numeric& in,
                const Numeric& value,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void NumericClip(// WS Generic Output:
                 Numeric& out,
                 // WS Generic Input:
                 const Numeric& in,
                 const Numeric& limit_low,
                 const Numeric& limit_high,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void NumericCreate(// WS Generic Output:
                   Numeric& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void NumericDivide(// WS Generic Output:
                   Numeric& out,
                   // WS Generic Input:
                   const Numeric& in,
                   const Numeric& value,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void NumericFromVector(// WS Generic Output:
                       Numeric& out,
                       // WS Generic Input:
                       const Vector& in,
                       const String& op,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void NumericMultiply(// WS Generic Output:
                     Numeric& out,
                     // WS Generic Input:
                     const Numeric& in,
                     const Numeric& value,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void NumericSet(// WS Generic Output:
                Numeric& out,
                // WS Generic Input:
                const Numeric& value,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void NumericSubtract(// WS Generic Output:
                     Numeric& out,
                     // WS Generic Input:
                     const Numeric& in,
                     const Numeric& value,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void OEM(// Workspace reference:
         Workspace& ws,
         // WS Output:
         Vector& x,
         Vector& yf,
         Matrix& jacobian,
         Matrix& dxdy,
         Vector& oem_diagnostics,
         Vector& lm_ga_history,
         ArrayOfString& oem_errors,
         // WS Input:
         const Vector& xa,
         const CovarianceMatrix& covmat_sx,
         const Vector& y,
         const CovarianceMatrix& covmat_se,
         const ArrayOfRetrievalQuantity& jacobian_quantities,
         const Agenda& inversion_iterate_agenda,
         // WS Generic Input:
         const String& method,
         const Numeric& max_start_cost,
         const Vector& x_norm,
         const Index& max_iter,
         const Numeric& stop_dx,
         const Vector& lm_ga_settings,
         const Index& clear_matrices,
         const Index& display_progress,
         // Verbosity object:
         const Verbosity& verbosity);
 
 
void OptimizeDoitPressureGrid(// Workspace reference:
                              Workspace& ws,
                              // WS Output:
                              Vector& p_grid,
                              Tensor4& pnd_field,
                              Tensor3& t_field,
                              ArrayOfArrayOfSingleScatteringData& scat_data_mono,
                              Tensor3& z_field,
                              ArrayOfIndex& cloudbox_limits,
                              Tensor6& cloudbox_field_mono,
                              Tensor7& pha_mat_doit,
                              Tensor4& vmr_field,
                              Vector& p_grid_orig,
                              // WS Input:
                              const Vector& f_grid,
                              const Index& f_index,
                              const Agenda& propmat_clearsky_agenda,
                              // WS Generic Input:
                              const Numeric& tau_scat_max,
                              const Numeric& sgl_alb_max,
                              const Index& cloudbox_size_max,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void PFromZSimple(// WS Generic Output:
                  Vector& p_grid,
                  // WS Generic Input:
                  const Vector& z_grid,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void PlanetSet(// Workspace reference:
               Workspace& ws,
               // WS Output:
               Agenda& g0_agenda,
               Vector& refellipsoid,
               Numeric& molarmass_dry_air,
               Numeric& planet_rotation_period,
               // WS Generic Input:
               const String& option,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void PpathCreate(// WS Generic Output:
                 Ppath& out,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void PpathSet(// WS Generic Output:
              Ppath& out,
              // WS Generic Input:
              const Ppath& value,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void PredefinedModelDataCreate(// WS Generic Output:
                               PredefinedModelData& out,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void PredefinedModelDataSet(// WS Generic Output:
                            PredefinedModelData& out,
                            // WS Generic Input:
                            const PredefinedModelData& value,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void PrintPhysicalConstants(// Verbosity object:
                            const Verbosity& verbosity);
 
 
void PropagationMatrixCreate(// WS Generic Output:
                             PropagationMatrix& out,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void PropagationMatrixSet(// WS Generic Output:
                          PropagationMatrix& out,
                          // WS Generic Input:
                          const PropagationMatrix& value,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void QuantumIdentifierCreate(// WS Generic Output:
                             QuantumIdentifier& out,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void QuantumIdentifierSet(// WS Generic Output:
                          QuantumIdentifier& out,
                          // WS Generic Input:
                          const QuantumIdentifier& value,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void RT4Calc(// Workspace reference:
             Workspace& ws,
             // WS Output:
             Tensor7& cloudbox_field,
             Vector& za_grid,
             Vector& aa_grid,
             // WS Input:
             const Index& atmfields_checked,
             const Index& atmgeom_checked,
             const Index& scat_data_checked,
             const Index& cloudbox_checked,
             const Index& cloudbox_on,
             const ArrayOfIndex& cloudbox_limits,
             const Agenda& propmat_clearsky_agenda,
             const Agenda& surface_rtprop_agenda,
             const Index& atmosphere_dim,
             const Tensor4& pnd_field,
             const Tensor3& t_field,
             const Tensor3& z_field,
             const Tensor4& vmr_field,
             const Vector& p_grid,
             const ArrayOfArrayOfSingleScatteringData& scat_data,
             const Vector& f_grid,
             const Index& stokes_dim,
             const Matrix& z_surface,
             // WS Generic Input:
             const Index& nstreams,
             const String& pfct_method,
             const String& quad_type,
             const Index& add_straight_angles,
             const Index& pfct_aa_grid_size,
             const Index& auto_inc_nstreams,
             const Index& robust,
             const Index& za_interp_order,
             const Index& cos_za_interp,
             const Numeric& max_delta_tau,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void RT4CalcWithRT4Surface(// Workspace reference:
                           Workspace& ws,
                           // WS Output:
                           Tensor7& cloudbox_field,
                           Vector& za_grid,
                           Vector& aa_grid,
                           // WS Input:
                           const Index& atmfields_checked,
                           const Index& atmgeom_checked,
                           const Index& scat_data_checked,
                           const Index& cloudbox_checked,
                           const Index& cloudbox_on,
                           const ArrayOfIndex& cloudbox_limits,
                           const Agenda& propmat_clearsky_agenda,
                           const Index& atmosphere_dim,
                           const Tensor4& pnd_field,
                           const Tensor3& t_field,
                           const Tensor3& z_field,
                           const Tensor4& vmr_field,
                           const Vector& p_grid,
                           const ArrayOfArrayOfSingleScatteringData& scat_data,
                           const Vector& f_grid,
                           const Index& stokes_dim,
                           const Matrix& z_surface,
                           const Numeric& surface_skin_t,
                           const Vector& surface_scalar_reflectivity,
                           const Tensor3& surface_reflectivity,
                           const GriddedField3& surface_complex_refr_index,
                           // WS Generic Input:
                           const Index& nstreams,
                           const String& pfct_method,
                           const String& ground_type,
                           const String& quad_type,
                           const Index& add_straight_angles,
                           const Index& pfct_aa_grid_size,
                           const Index& auto_inc_nstreams,
                           const Index& robust,
                           const Index& za_interp_order,
                           const Index& cos_za_interp,
                           const Numeric& max_delta_tau,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void RT4Test(// WS Generic Output:
             Tensor4& out_rad,
             // WS Generic Input:
             const String& datapath,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void RadarOnionPeelingTableCalc(// Workspace reference:
                                Workspace& ws,
                                // WS Generic Output:
                                ArrayOfGriddedField3& invtable,
                                // WS Input:
                                const Vector& f_grid,
                                const ArrayOfString& scat_species,
                                const ArrayOfArrayOfSingleScatteringData& scat_data,
                                const ArrayOfArrayOfScatteringMetaData& scat_meta,
                                const ArrayOfAgenda& pnd_agenda_array,
                                const ArrayOfArrayOfString& pnd_agenda_array_input_names,
                                // WS Generic Input:
                                const Index& i_species,
                                const Vector& dbze_grid,
                                const Vector& t_grid,
                                const Numeric& wc_min,
                                const Numeric& wc_max,
                                const Numeric& ze_tref,
                                const Numeric& k2,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void RadiationFieldSpectralIntegrate(// WS Generic Output:
                                     Tensor4& radiation_field,
                                     // WS Input:
                                     const Vector& f_grid,
                                     // WS Generic Input:
                                     const Tensor5& spectral_radiation_field,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void RadiationFieldSpectralIntegrate(// WS Generic Output:
                                     Tensor5& radiation_field,
                                     // WS Input:
                                     const Vector& f_grid,
                                     // WS Generic Input:
                                     const Tensor7& spectral_radiation_field,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void RadiationVectorCreate(// WS Generic Output:
                           RadiationVector& out,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void RadiationVectorSet(// WS Generic Output:
                        RadiationVector& out,
                        // WS Generic Input:
                        const RadiationVector& value,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void RationalAdd(// WS Generic Output:
                 Rational& out,
                 // WS Generic Input:
                 const Rational& in,
                 const Rational& value,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void RationalCreate(// WS Generic Output:
                    Rational& out,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void RationalDivide(// WS Generic Output:
                    Rational& out,
                    // WS Generic Input:
                    const Rational& in,
                    const Rational& value,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void RationalMultiply(// WS Generic Output:
                      Rational& out,
                      // WS Generic Input:
                      const Rational& in,
                      const Rational& value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void RationalSet(// WS Generic Output:
                 Rational& out,
                 // WS Generic Input:
                 const Rational& value,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void RationalSubtract(// WS Generic Output:
                      Rational& out,
                      // WS Generic Input:
                      const Rational& in,
                      const Rational& value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void ReadARTSCAT(// WS Output:
                 ArrayOfAbsorptionLines& abs_lines,
                 // WS Generic Input:
                 const String& filename,
                 const Numeric& fmin,
                 const Numeric& fmax,
                 const String& globalquantumnumbers,
                 const String& localquantumnumbers,
                 const String& normalization_option,
                 const String& mirroring_option,
                 const String& population_option,
                 const String& lineshapetype_option,
                 const String& cutoff_option,
                 const Numeric& cutoff_value,
                 const Numeric& linemixinglimit_value,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void ReadArrayOfARTSCAT(// WS Output:
                        ArrayOfAbsorptionLines& abs_lines,
                        // WS Generic Input:
                        const String& filename,
                        const Numeric& fmin,
                        const Numeric& fmax,
                        const String& globalquantumnumbers,
                        const String& localquantumnumbers,
                        const String& normalization_option,
                        const String& mirroring_option,
                        const String& population_option,
                        const String& lineshapetype_option,
                        const String& cutoff_option,
                        const Numeric& cutoff_value,
                        const Numeric& linemixinglimit_value,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void ReadHITRAN(// WS Output:
                ArrayOfAbsorptionLines& abs_lines,
                // WS Generic Input:
                const String& filename,
                const Numeric& fmin,
                const Numeric& fmax,
                const String& globalquantumnumbers,
                const String& localquantumnumbers,
                const String& hitran_type,
                const String& normalization_option,
                const String& mirroring_option,
                const String& population_option,
                const String& lineshapetype_option,
                const String& cutoff_option,
                const Numeric& cutoff_value,
                const Numeric& linemixinglimit_value,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void ReadJPL(// WS Output:
             ArrayOfAbsorptionLines& abs_lines,
             // WS Generic Input:
             const String& filename,
             const Numeric& fmin,
             const Numeric& fmax,
             const String& globalquantumnumbers,
             const String& localquantumnumbers,
             const String& normalization_option,
             const String& mirroring_option,
             const String& population_option,
             const String& lineshapetype_option,
             const String& cutoff_option,
             const Numeric& cutoff_value,
             const Numeric& linemixinglimit_value,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void ReadLBLRTM(// WS Output:
                ArrayOfAbsorptionLines& abs_lines,
                // WS Generic Input:
                const String& filename,
                const Numeric& fmin,
                const Numeric& fmax,
                const String& globalquantumnumbers,
                const String& localquantumnumbers,
                const String& normalization_option,
                const String& mirroring_option,
                const String& population_option,
                const String& lineshapetype_option,
                const String& cutoff_option,
                const Numeric& cutoff_value,
                const Numeric& linemixinglimit_value,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void ReadSplitARTSCAT(// WS Output:
                      ArrayOfAbsorptionLines& abs_lines,
                      // WS Input:
                      const ArrayOfArrayOfSpeciesTag& abs_species,
                      // WS Generic Input:
                      const String& basename,
                      const Numeric& fmin,
                      const Numeric& fmax,
                      const String& globalquantumnumbers,
                      const String& localquantumnumbers,
                      const Index& ignore_missing,
                      const String& normalization_option,
                      const String& mirroring_option,
                      const String& population_option,
                      const String& lineshapetype_option,
                      const String& cutoff_option,
                      const Numeric& cutoff_value,
                      const Numeric& linemixinglimit_value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void ReadXsecData(// WS Output:
                  ArrayOfXsecRecord& xsec_fit_data,
                  // WS Input:
                  const ArrayOfArrayOfSpeciesTag& abs_species,
                  // WS Generic Input:
                  const String& basename,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Numeric& o,
            // WS Generic Input:
            const Vector& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Numeric& o,
            // WS Generic Input:
            const Matrix& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Numeric& o,
            // WS Generic Input:
            const Tensor3& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Numeric& o,
            // WS Generic Input:
            const Tensor4& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Numeric& o,
            // WS Generic Input:
            const Tensor5& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Numeric& o,
            // WS Generic Input:
            const Tensor6& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Numeric& o,
            // WS Generic Input:
            const Tensor7& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Vector& o,
            // WS Generic Input:
            const Matrix& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Vector& o,
            // WS Generic Input:
            const Tensor3& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Vector& o,
            // WS Generic Input:
            const Tensor4& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Vector& o,
            // WS Generic Input:
            const Tensor5& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Vector& o,
            // WS Generic Input:
            const Tensor6& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Vector& o,
            // WS Generic Input:
            const Tensor7& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Matrix& o,
            // WS Generic Input:
            const Tensor3& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Matrix& o,
            // WS Generic Input:
            const Tensor4& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Matrix& o,
            // WS Generic Input:
            const Tensor5& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Matrix& o,
            // WS Generic Input:
            const Tensor6& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Matrix& o,
            // WS Generic Input:
            const Tensor7& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Tensor3& o,
            // WS Generic Input:
            const Tensor4& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Tensor3& o,
            // WS Generic Input:
            const Tensor5& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Tensor3& o,
            // WS Generic Input:
            const Tensor6& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Tensor3& o,
            // WS Generic Input:
            const Tensor7& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Tensor4& o,
            // WS Generic Input:
            const Tensor5& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Tensor4& o,
            // WS Generic Input:
            const Tensor6& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Tensor4& o,
            // WS Generic Input:
            const Tensor7& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Tensor5& o,
            // WS Generic Input:
            const Tensor6& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Tensor5& o,
            // WS Generic Input:
            const Tensor7& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Reduce(// WS Generic Output:
            Tensor6& o,
            // WS Generic Input:
            const Tensor7& i,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void ScatElementsPndAndScatAdd(// WS Output:
                               ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                               ArrayOfGriddedField3& pnd_field_raw,
                               // WS Input:
                               const Index& atmosphere_dim,
                               // WS Generic Input:
                               const ArrayOfString& scat_data_files,
                               const ArrayOfString& pnd_field_files,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void ScatElementsSelect(// WS Output:
                        ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                        ArrayOfArrayOfScatteringMetaData& scat_meta,
                        // WS Input:
                        const ArrayOfString& scat_species,
                        // WS Generic Input:
                        const String& species,
                        const String& sizeparam,
                        const Numeric& sizemin,
                        const Numeric& sizemax,
                        const Numeric& tolerance,
                        const String& delim,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void ScatElementsToabs_speciesAdd(// WS Output:
                                  ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                                  ArrayOfGriddedField3& vmr_field_raw,
                                  ArrayOfArrayOfSpeciesTag& abs_species,
                                  Index& propmat_clearsky_agenda_checked,
                                  // WS Input:
                                  const Index& atmosphere_dim,
                                  const Vector& f_grid,
                                  // WS Generic Input:
                                  const ArrayOfString& scat_data_files,
                                  const ArrayOfString& pnd_field_files,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void ScatSpeciesExtendTemperature(// WS Output:
                                  ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                                  // WS Input:
                                  const ArrayOfString& scat_species,
                                  // WS Generic Input:
                                  const String& species,
                                  const String& scat_species_delim,
                                  const Numeric& T_low,
                                  const Numeric& T_high,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void ScatSpeciesInit(// WS Output:
                     ArrayOfString& scat_species,
                     ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                     ArrayOfArrayOfScatteringMetaData& scat_meta,
                     Index& scat_data_checked,
                     ArrayOfGriddedField3& pnd_field_raw,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void ScatSpeciesMerge(// WS Output:
                      Tensor4& pnd_field,
                      ArrayOfArrayOfSingleScatteringData& scat_data,
                      ArrayOfArrayOfScatteringMetaData& scat_meta,
                      ArrayOfString& scat_species,
                      Index& cloudbox_checked,
                      // WS Input:
                      const Index& atmosphere_dim,
                      const Index& cloudbox_on,
                      const ArrayOfIndex& cloudbox_limits,
                      const Tensor3& t_field,
                      const Tensor3& z_field,
                      const Matrix& z_surface,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void ScatSpeciesPndAndScatAdd(// WS Output:
                              ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                              ArrayOfGriddedField3& pnd_field_raw,
                              // WS Input:
                              const Index& atmosphere_dim,
                              // WS Generic Input:
                              const ArrayOfString& scat_data_files,
                              const String& pnd_fieldarray_file,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void ScatSpeciesScatAndMetaRead(// WS Output:
                                ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                                ArrayOfArrayOfScatteringMetaData& scat_meta,
                                // WS Generic Input:
                                const ArrayOfString& scat_data_files,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ScatSpeciesSizeMassInfo(// WS Output:
                             Vector& scat_species_x,
                             Numeric& scat_species_a,
                             Numeric& scat_species_b,
                             // WS Input:
                             const ArrayOfArrayOfScatteringMetaData& scat_meta,
                             // WS Generic Input:
                             const Index& species_index,
                             const String& x_unit,
                             const Numeric& x_fit_start,
                             const Numeric& x_fit_end,
                             const Index& do_only_x,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ScatteringMetaDataCreate(// WS Generic Output:
                              ScatteringMetaData& out,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void ScatteringMetaDataSet(// WS Generic Output:
                           ScatteringMetaData& out,
                           // WS Generic Input:
                           const ScatteringMetaData& value,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void SetNumberOfThreads(// WS Generic Input:
                        const Index& nthreads,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void SingleScatteringDataCreate(// WS Generic Output:
                                SingleScatteringData& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void SingleScatteringDataSet(// WS Generic Output:
                             SingleScatteringData& out,
                             // WS Generic Input:
                             const SingleScatteringData& value,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void Sleep(// WS Generic Input:
           const Numeric& time,
           // Verbosity object:
           const Verbosity& verbosity);
 
 
void SparseCreate(// WS Generic Output:
                  Sparse& out,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void SparseIdentity(// WS Generic Output:
                    Sparse& out,
                    // WS Generic Input:
                    const Index& n,
                    const Numeric& value,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void SparseSet(// WS Generic Output:
               Sparse& out,
               // WS Generic Input:
               const Sparse& value,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void SparseSparseMultiply(// WS Generic Output:
                          Sparse& M,
                          // WS Generic Input:
                          const Sparse& M1,
                          const Sparse& M2,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void SpeciesIsotopologueRatiosCreate(// WS Generic Output:
                                     SpeciesIsotopologueRatios& out,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void SpeciesIsotopologueRatiosSet(// WS Generic Output:
                                  SpeciesIsotopologueRatios& out,
                                  // WS Generic Input:
                                  const SpeciesIsotopologueRatios& value,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void StokesVectorCreate(// WS Generic Output:
                        StokesVector& out,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void StokesVectorSet(// WS Generic Output:
                     StokesVector& out,
                     // WS Generic Input:
                     const StokesVector& value,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void StringCreate(// WS Generic Output:
                  String& out,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void StringJoin(// WS Generic Output:
                String& out,
                // WS Generic Input:
                const String& in1,
                const String& in2,
                const String& in3,
                const String& in4,
                const String& in5,
                const String& in6,
                const String& in7,
                const String& in8,
                const String& in9,
                const String& in10,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void StringSet(// WS Generic Output:
               String& out,
               // WS Generic Input:
               const String& value,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void SurfaceBlackbody(// WS Output:
                      Matrix& surface_los,
                      Tensor4& surface_rmatrix,
                      ArrayOfTensor4& dsurface_rmatrix_dx,
                      Matrix& surface_emission,
                      ArrayOfMatrix& dsurface_emission_dx,
                      // WS Input:
                      const Index& stokes_dim,
                      const Index& atmosphere_dim,
                      const Vector& lat_grid,
                      const Vector& lon_grid,
                      const Vector& f_grid,
                      const Vector& rtp_pos,
                      const Vector& rtp_los,
                      const Tensor3& surface_props_data,
                      const ArrayOfString& surface_props_names,
                      const ArrayOfString& dsurface_names,
                      const Index& jacobian_do,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void SurfaceDummy(// WS Output:
                  ArrayOfTensor4& dsurface_rmatrix_dx,
                  ArrayOfMatrix& dsurface_emission_dx,
                  // WS Input:
                  const Index& atmosphere_dim,
                  const Vector& lat_grid,
                  const Vector& lon_grid,
                  const Tensor3& surface_props_data,
                  const ArrayOfString& surface_props_names,
                  const ArrayOfString& dsurface_names,
                  const Index& jacobian_do,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void SurfaceFastem(// WS Output:
                   Matrix& surface_los,
                   Tensor4& surface_rmatrix,
                   ArrayOfTensor4& dsurface_rmatrix_dx,
                   Matrix& surface_emission,
                   ArrayOfMatrix& dsurface_emission_dx,
                   // WS Input:
                   const Index& stokes_dim,
                   const Index& atmosphere_dim,
                   const Vector& lat_grid,
                   const Vector& lon_grid,
                   const Vector& f_grid,
                   const Vector& rtp_pos,
                   const Vector& rtp_los,
                   const Tensor3& surface_props_data,
                   const ArrayOfString& surface_props_names,
                   const ArrayOfString& dsurface_names,
                   const Index& jacobian_do,
                   // WS Generic Input:
                   const Vector& transmittance,
                   const Index& fastem_version,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void SurfaceFlatScalarReflectivity(// WS Output:
                                   Matrix& surface_los,
                                   Tensor4& surface_rmatrix,
                                   ArrayOfTensor4& dsurface_rmatrix_dx,
                                   Matrix& surface_emission,
                                   ArrayOfMatrix& dsurface_emission_dx,
                                   // WS Input:
                                   const Index& stokes_dim,
                                   const Index& atmosphere_dim,
                                   const Vector& lat_grid,
                                   const Vector& lon_grid,
                                   const Vector& f_grid,
                                   const Vector& rtp_pos,
                                   const Vector& rtp_los,
                                   const Vector& specular_los,
                                   const Tensor3& surface_props_data,
                                   const ArrayOfString& surface_props_names,
                                   const ArrayOfString& dsurface_names,
                                   const Index& jacobian_do,
                                   // WS Generic Input:
                                   const Vector& f_reflectivities,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void SurfaceTessem(// WS Output:
                   Matrix& surface_los,
                   Tensor4& surface_rmatrix,
                   ArrayOfTensor4& dsurface_rmatrix_dx,
                   Matrix& surface_emission,
                   ArrayOfMatrix& dsurface_emission_dx,
                   // WS Input:
                   const Index& stokes_dim,
                   const Index& atmosphere_dim,
                   const Vector& lat_grid,
                   const Vector& lon_grid,
                   const Vector& f_grid,
                   const Vector& rtp_pos,
                   const Vector& rtp_los,
                   const TessemNN& tessem_neth,
                   const TessemNN& tessem_netv,
                   const Tensor3& surface_props_data,
                   const ArrayOfString& surface_props_names,
                   const ArrayOfString& dsurface_names,
                   const Index& jacobian_do,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void TMatrixTest(// Verbosity object:
                 const Verbosity& verbosity);
 
 
void TangentPointExtract(// WS Generic Output:
                         Vector& tan_pos,
                         // WS Input:
                         const Ppath& ppath,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void TangentPointPrint(// WS Input:
                       const Ppath& ppath,
                       // WS Generic Input:
                       const Index& level,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void TelsemAtlasCreate(// WS Generic Output:
                       TelsemAtlas& out,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void TelsemAtlasSet(// WS Generic Output:
                    TelsemAtlas& out,
                    // WS Generic Input:
                    const TelsemAtlas& value,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void Tensor3Add(// WS Generic Output:
                Tensor3& out,
                // WS Generic Input:
                const Tensor3& in,
                const Numeric& value,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void Tensor3Create(// WS Generic Output:
                   Tensor3& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Tensor3ExtractFromTensor4(// WS Generic Output:
                               Tensor3& out,
                               // WS Generic Input:
                               const Tensor4& in,
                               const Index& i,
                               const String& direction,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void Tensor3FromVector(// WS Generic Output:
                       Tensor3& out,
                       // WS Generic Input:
                       const Vector& v,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void Tensor3Multiply(// WS Generic Output:
                     Tensor3& out,
                     // WS Generic Input:
                     const Tensor3& in,
                     const Numeric& value,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void Tensor3Set(// WS Generic Output:
                Tensor3& out,
                // WS Generic Input:
                const Tensor3& value,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void Tensor3SetConstant(// WS Generic Output:
                        Tensor3& out,
                        // WS Input:
                        const Index& npages,
                        const Index& nrows,
                        const Index& ncols,
                        // WS Generic Input:
                        const Numeric& value,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void Tensor4Add(// WS Generic Output:
                Tensor4& out,
                // WS Generic Input:
                const Tensor4& in,
                const Numeric& value,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void Tensor4Create(// WS Generic Output:
                   Tensor4& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Tensor4Multiply(// WS Generic Output:
                     Tensor4& out,
                     // WS Generic Input:
                     const Tensor4& in,
                     const Numeric& value,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void Tensor4Set(// WS Generic Output:
                Tensor4& out,
                // WS Generic Input:
                const Tensor4& value,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void Tensor4SetConstant(// WS Generic Output:
                        Tensor4& out,
                        // WS Input:
                        const Index& nbooks,
                        const Index& npages,
                        const Index& nrows,
                        const Index& ncols,
                        // WS Generic Input:
                        const Numeric& value,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void Tensor5Create(// WS Generic Output:
                   Tensor5& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Tensor5Multiply(// WS Generic Output:
                     Tensor5& out,
                     // WS Generic Input:
                     const Tensor5& in,
                     const Numeric& value,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void Tensor5Set(// WS Generic Output:
                Tensor5& out,
                // WS Generic Input:
                const Tensor5& value,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void Tensor5SetConstant(// WS Generic Output:
                        Tensor5& out,
                        // WS Input:
                        const Index& nshelves,
                        const Index& nbooks,
                        const Index& npages,
                        const Index& nrows,
                        const Index& ncols,
                        // WS Generic Input:
                        const Numeric& value,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void Tensor6Create(// WS Generic Output:
                   Tensor6& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Tensor6Multiply(// WS Generic Output:
                     Tensor6& out,
                     // WS Generic Input:
                     const Tensor6& in,
                     const Numeric& value,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void Tensor6Set(// WS Generic Output:
                Tensor6& out,
                // WS Generic Input:
                const Tensor6& value,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void Tensor6SetConstant(// WS Generic Output:
                        Tensor6& out,
                        // WS Input:
                        const Index& nvitrines,
                        const Index& nshelves,
                        const Index& nbooks,
                        const Index& npages,
                        const Index& nrows,
                        const Index& ncols,
                        // WS Generic Input:
                        const Numeric& value,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void Tensor7Create(// WS Generic Output:
                   Tensor7& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Tensor7Multiply(// WS Generic Output:
                     Tensor7& out,
                     // WS Generic Input:
                     const Tensor7& in,
                     const Numeric& value,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void Tensor7Set(// WS Generic Output:
                Tensor7& out,
                // WS Generic Input:
                const Tensor7& value,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void Tensor7SetConstant(// WS Generic Output:
                        Tensor7& out,
                        // WS Input:
                        const Index& nlibraries,
                        const Index& nvitrines,
                        const Index& nshelves,
                        const Index& nbooks,
                        const Index& npages,
                        const Index& nrows,
                        const Index& ncols,
                        // WS Generic Input:
                        const Numeric& value,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void TessemNNCreate(// WS Generic Output:
                    TessemNN& out,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void TessemNNReadAscii(// WS Generic Output:
                       TessemNN& tessem_nn,
                       // WS Generic Input:
                       const String& filename,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void TessemNNSet(// WS Generic Output:
                 TessemNN& out,
                 // WS Generic Input:
                 const TessemNN& value,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void Test(// Verbosity object:
          const Verbosity& verbosity);
 
 
void TestArrayOfAgenda(// Workspace reference:
                       Workspace& ws,
                       // WS Input:
                       const ArrayOfAgenda& test_agenda_array,
                       // WS Generic Input:
                       const Index& index,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void TestTessem(// WS Generic Output:
                Vector& outvalues,
                // WS Generic Input:
                const TessemNN& net,
                const Vector& invalues,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void TimeCreate(// WS Generic Output:
                Time& out,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void TimeSet(// WS Generic Output:
             Time& out,
             // WS Generic Input:
             const Time& value,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void TimerCreate(// WS Generic Output:
                 Timer& out,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void TimerSet(// WS Generic Output:
              Timer& out,
              // WS Generic Input:
              const Timer& value,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void TransmissionMatrixCreate(// WS Generic Output:
                              TransmissionMatrix& out,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void TransmissionMatrixSet(// WS Generic Output:
                           TransmissionMatrix& out,
                           // WS Generic Input:
                           const TransmissionMatrix& value,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void Trapz(// WS Generic Output:
           Numeric& out,
           // WS Generic Input:
           const Vector& x,
           const Vector& y,
           // Verbosity object:
           const Verbosity& verbosity);
 
 
void VectorAdd(// WS Generic Output:
               Vector& out,
               // WS Generic Input:
               const Vector& in,
               const Numeric& value,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void VectorAddElementwise(// WS Generic Output:
                          Vector& c,
                          // WS Generic Input:
                          const Vector& a,
                          const Vector& b,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void VectorClip(// WS Generic Output:
                Vector& out,
                // WS Generic Input:
                const Vector& in,
                const Numeric& limit_low,
                const Numeric& limit_high,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void VectorCreate(// WS Generic Output:
                  Vector& out,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void VectorCrop(// WS Generic Output:
                Vector& out,
                // WS Generic Input:
                const Vector& in,
                const Numeric& min_value,
                const Numeric& max_value,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void VectorDivide(// WS Generic Output:
                  Vector& out,
                  // WS Generic Input:
                  const Vector& in,
                  const Numeric& value,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void VectorDivideElementwise(// WS Generic Output:
                             Vector& c,
                             // WS Generic Input:
                             const Vector& a,
                             const Vector& b,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void VectorExtractFromMatrix(// WS Generic Output:
                             Vector& out,
                             // WS Generic Input:
                             const Matrix& in,
                             const Index& i,
                             const String& direction,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void VectorFlip(// WS Generic Output:
                Vector& out,
                // WS Generic Input:
                const Vector& in,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void VectorGaussian(// WS Generic Output:
                    Vector& y,
                    // WS Generic Input:
                    const Vector& x,
                    const Numeric& x0,
                    const Numeric& si,
                    const Numeric& fwhm,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void VectorInsertGridPoints(// WS Generic Output:
                            Vector& out,
                            // WS Generic Input:
                            const Vector& in,
                            const Vector& points,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void VectorLinSpace(// WS Generic Output:
                    Vector& out,
                    // WS Generic Input:
                    const Numeric& start,
                    const Numeric& stop,
                    const Numeric& step,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void VectorLogSpace(// WS Generic Output:
                    Vector& out,
                    // WS Generic Input:
                    const Numeric& start,
                    const Numeric& stop,
                    const Numeric& step,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void VectorMatrixMultiply(// WS Generic Output:
                          Vector& y,
                          // WS Generic Input:
                          const Matrix& M,
                          const Vector& x,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void VectorMultiply(// WS Generic Output:
                    Vector& out,
                    // WS Generic Input:
                    const Vector& in,
                    const Numeric& value,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void VectorMultiplyElementwise(// WS Generic Output:
                               Vector& c,
                               // WS Generic Input:
                               const Vector& a,
                               const Vector& b,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void VectorNLinSpace(// WS Generic Output:
                     Vector& out,
                     // WS Input:
                     const Index& nelem,
                     // WS Generic Input:
                     const Numeric& start,
                     const Numeric& stop,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void VectorNLinSpaceVector(// WS Generic Output:
                           Vector& out,
                           // WS Input:
                           const Index& nelem,
                           // WS Generic Input:
                           const Vector& y,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void VectorNLogSpace(// WS Generic Output:
                     Vector& out,
                     // WS Input:
                     const Index& nelem,
                     // WS Generic Input:
                     const Numeric& start,
                     const Numeric& stop,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void VectorPower(// WS Generic Output:
                 Vector& out,
                 // WS Generic Input:
                 const Vector& in,
                 const Numeric& power,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void VectorReshapeMatrix(// WS Generic Output:
                         Vector& out,
                         // WS Generic Input:
                         const Matrix& in,
                         const String& direction,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void VectorSet(// WS Generic Output:
               Vector& out,
               // WS Generic Input:
               const Vector& value,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void VectorSetConstant(// WS Generic Output:
                       Vector& out,
                       // WS Input:
                       const Index& nelem,
                       // WS Generic Input:
                       const Numeric& value,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void VectorSparseMultiply(// WS Generic Output:
                          Vector& y,
                          // WS Generic Input:
                          const Sparse& M,
                          const Vector& x,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void VectorSubtract(// WS Generic Output:
                    Vector& out,
                    // WS Generic Input:
                    const Vector& in,
                    const Numeric& value,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void VectorSubtractElementwise(// WS Generic Output:
                               Vector& c,
                               // WS Generic Input:
                               const Vector& a,
                               const Vector& b,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void VectorZtanToZa1D(// WS Generic Output:
                      Vector& v_za,
                      // WS Input:
                      const Matrix& sensor_pos,
                      const Vector& refellipsoid,
                      const Index& atmosphere_dim,
                      // WS Generic Input:
                      const Vector& v_ztan,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void VectorZtanToZaRefr1D(// Workspace reference:
                          Workspace& ws,
                          // WS Generic Output:
                          Vector& v_za,
                          // WS Input:
                          const Agenda& refr_index_air_agenda,
                          const Matrix& sensor_pos,
                          const Vector& p_grid,
                          const Tensor3& t_field,
                          const Tensor3& z_field,
                          const Tensor4& vmr_field,
                          const Vector& refellipsoid,
                          const Index& atmosphere_dim,
                          const Vector& f_grid,
                          // WS Generic Input:
                          const Vector& v_ztan,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void VerbosityCreate(// WS Generic Output:
                     Verbosity& out,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void VerbositySet(// WS Generic Output:
                  Verbosity& out,
                  // WS Generic Input:
                  const Verbosity& value,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void WMRFSelectChannels(// WS Output:
                        Vector& f_grid,
                        Sparse& wmrf_weights,
                        Vector& f_backend,
                        // WS Input:
                        const ArrayOfIndex& wmrf_channels,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void Wigner3Init(// WS Output:
                 Index& wigner_initialized,
                 // WS Generic Input:
                 const Index& fast_wigner_stored_symbols,
                 const Index& largest_wigner_symbol_parameter,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void Wigner3Unload(// WS Output:
                   Index& wigner_initialized,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Wigner6Init(// WS Output:
                 Index& wigner_initialized,
                 // WS Generic Input:
                 const Index& fast_wigner_stored_symbols,
                 const Index& largest_wigner_symbol_parameter,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void Wigner6Unload(// WS Output:
                   Index& wigner_initialized,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void WignerFastInfoPrint(// WS Input:
                         const Index& wigner_initialized,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void WindFieldsCalc(// WS Output:
                    Tensor3& wind_u_field,
                    Tensor3& wind_v_field,
                    Tensor3& wind_w_field,
                    // WS Input:
                    const Vector& p_grid,
                    const Vector& lat_grid,
                    const Vector& lon_grid,
                    const GriddedField3& wind_u_field_raw,
                    const GriddedField3& wind_v_field_raw,
                    const GriddedField3& wind_w_field_raw,
                    const Index& atmosphere_dim,
                    // WS Generic Input:
                    const Index& interp_order,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void WindFieldsCalcExpand1D(// WS Output:
                            Tensor3& wind_u_field,
                            Tensor3& wind_v_field,
                            Tensor3& wind_w_field,
                            // WS Input:
                            const Vector& p_grid,
                            const Vector& lat_grid,
                            const Vector& lon_grid,
                            const GriddedField3& wind_u_field_raw,
                            const GriddedField3& wind_v_field_raw,
                            const GriddedField3& wind_w_field_raw,
                            const Index& atmosphere_dim,
                            // WS Generic Input:
                            const Index& interp_order,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void WindRawRead(// WS Output:
                 GriddedField3& wind_u_field_raw,
                 GriddedField3& wind_v_field_raw,
                 GriddedField3& wind_w_field_raw,
                 // WS Generic Input:
                 const String& basename,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void WriteBuiltinPartitionFunctionsXML(// WS Input:
                                       const String& output_file_format,
                                       // WS Generic Input:
                                       const String& dir,
                                       const Numeric& Tlow,
                                       const Numeric& Tupp,
                                       const Index& N,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void WriteMolTau(// WS Input:
                 const Vector& f_grid,
                 const Tensor3& z_field,
                 const Tensor7& propmat_clearsky_field,
                 const Index& atmosphere_dim,
                 // WS Generic Input:
                 const String& filename,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void ZFromPSimple(// WS Generic Output:
                  Vector& z_grid,
                  // WS Generic Input:
                  const Vector& p_grid,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void abs_cia_dataAddCIARecord(// WS Output:
                              ArrayOfCIARecord& abs_cia_data,
                              // WS Generic Input:
                              const CIARecord& cia_record,
                              const Index& clobber,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void abs_cia_dataReadFromCIA(// WS Output:
                             ArrayOfCIARecord& abs_cia_data,
                             // WS Input:
                             const ArrayOfArrayOfSpeciesTag& abs_species,
                             // WS Generic Input:
                             const String& catalogpath,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void abs_cia_dataReadFromXML(// WS Output:
                             ArrayOfCIARecord& abs_cia_data,
                             // WS Input:
                             const ArrayOfArrayOfSpeciesTag& abs_species,
                             // WS Generic Input:
                             const String& filename,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void abs_cia_dataReadSpeciesSplitCatalog(// WS Output:
                                         ArrayOfCIARecord& abs_cia_data,
                                         // WS Input:
                                         const ArrayOfArrayOfSpeciesTag& abs_species,
                                         // WS Generic Input:
                                         const String& basename,
                                         const Index& robust,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void abs_hitran_relmat_dataReadHitranRelmatDataAndLines(// WS Output:
                                                        HitranRelaxationMatrixData& abs_hitran_relmat_data,
                                                        ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                        // WS Input:
                                                        const ArrayOfArrayOfSpeciesTag& abs_species,
                                                        // WS Generic Input:
                                                        const String& basedir,
                                                        const Numeric& linemixinglimit,
                                                        const Numeric& fmin,
                                                        const Numeric& fmax,
                                                        const Numeric& stot,
                                                        const String& mode,
                                                        // Verbosity object:
                                                        const Verbosity& verbosity);
 
 
void abs_linesAdaptOnTheFlyLineMixing(// WS Output:
                                      ArrayOfAbsorptionLines& abs_lines,
                                      // WS Input:
                                      const MapOfErrorCorrectedSuddenData& ecs_data,
                                      // WS Generic Input:
                                      const Vector& t_grid,
                                      const Numeric& pressure,
                                      const Index& order,
                                      const Index& robust,
                                      const Index& rosenkranz_adaptation,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void abs_linesBaseParameterMatchingLevel(// WS Output:
                                         ArrayOfAbsorptionLines& abs_lines,
                                         // WS Generic Input:
                                         const QuantumIdentifier& QI,
                                         const String& parameter_name,
                                         const Numeric& change,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void abs_linesBaseParameterMatchingLevels(// WS Output:
                                          ArrayOfAbsorptionLines& abs_lines,
                                          // WS Generic Input:
                                          const ArrayOfQuantumIdentifier& QI,
                                          const String& parameter_name,
                                          const Vector& change,
                                          // Verbosity object:
                                          const Verbosity& verbosity);
 
 
void abs_linesBaseParameterMatchingLines(// WS Output:
                                         ArrayOfAbsorptionLines& abs_lines,
                                         // WS Generic Input:
                                         const QuantumIdentifier& QI,
                                         const String& parameter_name,
                                         const Numeric& change,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void abs_linesChangeBaseParameterForMatchingLevel(// WS Output:
                                                  ArrayOfAbsorptionLines& abs_lines,
                                                  // WS Generic Input:
                                                  const QuantumIdentifier& QI,
                                                  const String& parameter_name,
                                                  const Numeric& change,
                                                  const Index& relative,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);
 
 
void abs_linesChangeBaseParameterForMatchingLevels(// WS Output:
                                                   ArrayOfAbsorptionLines& abs_lines,
                                                   // WS Generic Input:
                                                   const ArrayOfQuantumIdentifier& QI,
                                                   const String& parameter_name,
                                                   const Vector& change,
                                                   const Index& relative,
                                                   // Verbosity object:
                                                   const Verbosity& verbosity);
 
 
void abs_linesChangeBaseParameterForMatchingLines(// WS Output:
                                                  ArrayOfAbsorptionLines& abs_lines,
                                                  // WS Generic Input:
                                                  const QuantumIdentifier& QI,
                                                  const String& parameter_name,
                                                  const Numeric& change,
                                                  const Index& relative,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);
 
 
void abs_linesCompact(// WS Output:
                      ArrayOfAbsorptionLines& abs_lines,
                      // WS Input:
                      const Vector& f_grid,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void abs_linesCutoff(// WS Output:
                     ArrayOfAbsorptionLines& abs_lines,
                     // WS Generic Input:
                     const String& option,
                     const Numeric& value,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void abs_linesCutoffMatch(// WS Output:
                          ArrayOfAbsorptionLines& abs_lines,
                          // WS Generic Input:
                          const String& option,
                          const Numeric& value,
                          const QuantumIdentifier& ID,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void abs_linesDeleteBadF0(// WS Output:
                          ArrayOfAbsorptionLines& abs_lines,
                          // WS Generic Input:
                          const Numeric& f0,
                          const Index& lower,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void abs_linesEmptyBroadeningParameters(// WS Output:
                                        ArrayOfAbsorptionLines& abs_lines,
                                        // Verbosity object:
                                        const Verbosity& verbosity);
 
 
void abs_linesFlatten(// WS Output:
                      ArrayOfAbsorptionLines& abs_lines,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void abs_linesKeepBand(// WS Output:
                       ArrayOfAbsorptionLines& abs_lines,
                       // WS Generic Input:
                       const QuantumIdentifier& qid,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void abs_linesLineShapeModelParametersMatchingLines(// WS Output:
                                                    ArrayOfAbsorptionLines& abs_lines,
                                                    // WS Generic Input:
                                                    const QuantumIdentifier& QI,
                                                    const String& parameter,
                                                    const String& species,
                                                    const String& temperaturemodel,
                                                    const Vector& new_values,
                                                    // Verbosity object:
                                                    const Verbosity& verbosity);
 
 
void abs_linesLineShapeType(// WS Output:
                            ArrayOfAbsorptionLines& abs_lines,
                            // WS Generic Input:
                            const String& option,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void abs_linesLineShapeTypeMatch(// WS Output:
                                 ArrayOfAbsorptionLines& abs_lines,
                                 // WS Generic Input:
                                 const String& option,
                                 const QuantumIdentifier& ID,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void abs_linesLinemixingLimit(// WS Output:
                              ArrayOfAbsorptionLines& abs_lines,
                              // WS Generic Input:
                              const Numeric& value,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void abs_linesLinemixingLimitMatch(// WS Output:
                                   ArrayOfAbsorptionLines& abs_lines,
                                   // WS Generic Input:
                                   const Numeric& value,
                                   const QuantumIdentifier& ID,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void abs_linesManualMirroring(// WS Output:
                              ArrayOfAbsorptionLines& abs_lines,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void abs_linesMirroring(// WS Output:
                        ArrayOfAbsorptionLines& abs_lines,
                        // WS Generic Input:
                        const String& option,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void abs_linesMirroringMatch(// WS Output:
                             ArrayOfAbsorptionLines& abs_lines,
                             // WS Generic Input:
                             const String& option,
                             const QuantumIdentifier& ID,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void abs_linesNormalization(// WS Output:
                            ArrayOfAbsorptionLines& abs_lines,
                            // WS Generic Input:
                            const String& option,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void abs_linesNormalizationMatch(// WS Output:
                                 ArrayOfAbsorptionLines& abs_lines,
                                 // WS Generic Input:
                                 const String& option,
                                 const QuantumIdentifier& ID,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void abs_linesPopulation(// WS Output:
                         ArrayOfAbsorptionLines& abs_lines,
                         // WS Generic Input:
                         const String& option,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void abs_linesPopulationMatch(// WS Output:
                              ArrayOfAbsorptionLines& abs_lines,
                              // WS Generic Input:
                              const String& option,
                              const QuantumIdentifier& ID,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void abs_linesReadSpeciesSplitCatalog(// WS Output:
                                      ArrayOfAbsorptionLines& abs_lines,
                                      // WS Generic Input:
                                      const String& basename,
                                      const Index& robust,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void abs_linesRemoveBand(// WS Output:
                         ArrayOfAbsorptionLines& abs_lines,
                         // WS Generic Input:
                         const QuantumIdentifier& qid,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void abs_linesRemoveEmptyBands(// WS Output:
                               ArrayOfAbsorptionLines& abs_lines,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void abs_linesRemoveLines(// WS Output:
                          ArrayOfAbsorptionLines& abs_lines,
                          // WS Generic Input:
                          const Numeric& lower_frequency,
                          const Numeric& upper_frequency,
                          const Numeric& lower_intensity,
                          const Index& safe,
                          const Index& flip_flims,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void abs_linesRemoveLinesFromSpecies(// WS Output:
                                     ArrayOfAbsorptionLines& abs_lines,
                                     // WS Generic Input:
                                     const ArrayOfSpeciesTag& species,
                                     const Numeric& lower_frequency,
                                     const Numeric& upper_frequency,
                                     const Numeric& lower_intensity,
                                     const Index& safe,
                                     const Index& flip_flims,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void abs_linesReplaceBands(// WS Output:
                           ArrayOfAbsorptionLines& abs_lines,
                           // WS Generic Input:
                           const ArrayOfAbsorptionLines& replacing_bands,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void abs_linesReplaceLines(// WS Output:
                           ArrayOfAbsorptionLines& abs_lines,
                           // WS Generic Input:
                           const ArrayOfAbsorptionLines& replacing_lines,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void abs_linesSort(// WS Output:
                   ArrayOfAbsorptionLines& abs_lines,
                   // WS Generic Input:
                   const String& option,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void abs_linesT0(// WS Output:
                 ArrayOfAbsorptionLines& abs_lines,
                 // WS Generic Input:
                 const Numeric& value,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void abs_linesT0Match(// WS Output:
                      ArrayOfAbsorptionLines& abs_lines,
                      // WS Generic Input:
                      const Numeric& value,
                      const QuantumIdentifier& ID,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void abs_linesTurnOffLineMixing(// WS Output:
                                ArrayOfAbsorptionLines& abs_lines,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void abs_linesWriteSpeciesSplitCatalog(// WS Input:
                                       const String& output_file_format,
                                       const ArrayOfAbsorptionLines& abs_lines,
                                       // WS Generic Input:
                                       const String& basename,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void abs_linesZeemanCoefficients(// WS Output:
                                 ArrayOfAbsorptionLines& abs_lines,
                                 // WS Generic Input:
                                 const ArrayOfQuantumIdentifier& qid,
                                 const Vector& gs,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void abs_lines_per_speciesAdaptHitranLineMixing(// WS Output:
                                                ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                // WS Input:
                                                const HitranRelaxationMatrixData& abs_hitran_relmat_data,
                                                // WS Generic Input:
                                                const Vector& t_grid,
                                                const Numeric& pressure,
                                                const Index& order,
                                                // Verbosity object:
                                                const Verbosity& verbosity);
 
 
void abs_lines_per_speciesAdaptOnTheFlyLineMixing(// WS Output:
                                                  ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                  // WS Input:
                                                  const MapOfErrorCorrectedSuddenData& ecs_data,
                                                  // WS Generic Input:
                                                  const Vector& t_grid,
                                                  const Numeric& pressure,
                                                  const Index& order,
                                                  const Index& robust,
                                                  const Index& rosenkranz_adaptation,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);
 
 
void abs_lines_per_speciesBaseParameterMatchingLevel(// WS Output:
                                                     ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                     // WS Generic Input:
                                                     const QuantumIdentifier& QI,
                                                     const String& parameter_name,
                                                     const Numeric& change,
                                                     // Verbosity object:
                                                     const Verbosity& verbosity);
 
 
void abs_lines_per_speciesBaseParameterMatchingLevels(// WS Output:
                                                      ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                      // WS Generic Input:
                                                      const ArrayOfQuantumIdentifier& QI,
                                                      const String& parameter_name,
                                                      const Vector& change,
                                                      // Verbosity object:
                                                      const Verbosity& verbosity);
 
 
void abs_lines_per_speciesChangeBaseParameterForMatchingLevel(// WS Output:
                                                              ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                              // WS Generic Input:
                                                              const QuantumIdentifier& QI,
                                                              const String& parameter_name,
                                                              const Numeric& change,
                                                              const Index& relative,
                                                              // Verbosity object:
                                                              const Verbosity& verbosity);
 
 
void abs_lines_per_speciesChangeBaseParameterForMatchingLevels(// WS Output:
                                                               ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                               // WS Generic Input:
                                                               const ArrayOfQuantumIdentifier& QI,
                                                               const String& parameter_name,
                                                               const Vector& change,
                                                               const Index& relative,
                                                               // Verbosity object:
                                                               const Verbosity& verbosity);
 
 
void abs_lines_per_speciesChangeBaseParameterForMatchingLines(// WS Output:
                                                              ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                              // WS Generic Input:
                                                              const QuantumIdentifier& QI,
                                                              const String& parameter_name,
                                                              const Numeric& change,
                                                              const Index& relative,
                                                              // Verbosity object:
                                                              const Verbosity& verbosity);
 
 
void abs_lines_per_speciesChangeBaseParameterForSpecies(// WS Output:
                                                        ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                        // WS Input:
                                                        const ArrayOfArrayOfSpeciesTag& abs_species,
                                                        // WS Generic Input:
                                                        const QuantumIdentifier& QI,
                                                        const String& parameter_name,
                                                        const Numeric& change,
                                                        const Index& relative,
                                                        const String& species_tag,
                                                        // Verbosity object:
                                                        const Verbosity& verbosity);
 
 
void abs_lines_per_speciesCompact(// WS Output:
                                  ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                  // WS Input:
                                  const Vector& f_grid,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void abs_lines_per_speciesCreateFromLines(// WS Output:
                                          ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                          // WS Input:
                                          const ArrayOfAbsorptionLines& abs_lines,
                                          const ArrayOfArrayOfSpeciesTag& abs_species,
                                          // Verbosity object:
                                          const Verbosity& verbosity);
 
 
void abs_lines_per_speciesCutoff(// WS Output:
                                 ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                 // WS Generic Input:
                                 const String& option,
                                 const Numeric& value,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void abs_lines_per_speciesCutoffMatch(// WS Output:
                                      ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                      // WS Generic Input:
                                      const String& option,
                                      const Numeric& value,
                                      const QuantumIdentifier& ID,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void abs_lines_per_speciesCutoffSpecies(// WS Output:
                                        ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                        // WS Input:
                                        const ArrayOfArrayOfSpeciesTag& abs_species,
                                        // WS Generic Input:
                                        const String& option,
                                        const Numeric& value,
                                        const String& species_tag,
                                        // Verbosity object:
                                        const Verbosity& verbosity);
 
 
void abs_lines_per_speciesFlatten(// WS Output:
                                  ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void abs_lines_per_speciesLineShapeModelParametersMatchingLines(// WS Output:
                                                                ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                                // WS Generic Input:
                                                                const QuantumIdentifier& QI,
                                                                const String& parameter,
                                                                const String& species,
                                                                const String& temperaturemodel,
                                                                const Vector& new_values,
                                                                // Verbosity object:
                                                                const Verbosity& verbosity);
 
 
void abs_lines_per_speciesLineShapeType(// WS Output:
                                        ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                        // WS Generic Input:
                                        const String& option,
                                        // Verbosity object:
                                        const Verbosity& verbosity);
 
 
void abs_lines_per_speciesLineShapeTypeMatch(// WS Output:
                                             ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                             // WS Generic Input:
                                             const String& option,
                                             const QuantumIdentifier& ID,
                                             // Verbosity object:
                                             const Verbosity& verbosity);
 
 
void abs_lines_per_speciesLineShapeTypeSpecies(// WS Output:
                                               ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                               // WS Input:
                                               const ArrayOfArrayOfSpeciesTag& abs_species,
                                               // WS Generic Input:
                                               const String& option,
                                               const String& species_tag,
                                               // Verbosity object:
                                               const Verbosity& verbosity);
 
 
void abs_lines_per_speciesLinemixingLimit(// WS Output:
                                          ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                          // WS Generic Input:
                                          const Numeric& value,
                                          // Verbosity object:
                                          const Verbosity& verbosity);
 
 
void abs_lines_per_speciesLinemixingLimitMatch(// WS Output:
                                               ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                               // WS Generic Input:
                                               const Numeric& value,
                                               const QuantumIdentifier& ID,
                                               // Verbosity object:
                                               const Verbosity& verbosity);
 
 
void abs_lines_per_speciesLinemixingLimitSpecies(// WS Output:
                                                 ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                 // WS Input:
                                                 const ArrayOfArrayOfSpeciesTag& abs_species,
                                                 // WS Generic Input:
                                                 const Numeric& value,
                                                 const String& species_tag,
                                                 // Verbosity object:
                                                 const Verbosity& verbosity);
 
 
void abs_lines_per_speciesManualMirroring(// WS Output:
                                          ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                          // Verbosity object:
                                          const Verbosity& verbosity);
 
 
void abs_lines_per_speciesManualMirroringSpecies(// WS Output:
                                                 ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                 // WS Input:
                                                 const ArrayOfArrayOfSpeciesTag& abs_species,
                                                 // WS Generic Input:
                                                 const ArrayOfSpeciesTag& species,
                                                 // Verbosity object:
                                                 const Verbosity& verbosity);
 
 
void abs_lines_per_speciesMirroring(// WS Output:
                                    ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                    // WS Generic Input:
                                    const String& option,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void abs_lines_per_speciesMirroringMatch(// WS Output:
                                         ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                         // WS Generic Input:
                                         const String& option,
                                         const QuantumIdentifier& ID,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void abs_lines_per_speciesMirroringSpecies(// WS Output:
                                           ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                           // WS Input:
                                           const ArrayOfArrayOfSpeciesTag& abs_species,
                                           // WS Generic Input:
                                           const String& option,
                                           const String& species_tag,
                                           // Verbosity object:
                                           const Verbosity& verbosity);
 
 
void abs_lines_per_speciesNormalization(// WS Output:
                                        ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                        // WS Generic Input:
                                        const String& option,
                                        // Verbosity object:
                                        const Verbosity& verbosity);
 
 
void abs_lines_per_speciesNormalizationMatch(// WS Output:
                                             ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                             // WS Generic Input:
                                             const String& option,
                                             const QuantumIdentifier& ID,
                                             // Verbosity object:
                                             const Verbosity& verbosity);
 
 
void abs_lines_per_speciesNormalizationSpecies(// WS Output:
                                               ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                               // WS Input:
                                               const ArrayOfArrayOfSpeciesTag& abs_species,
                                               // WS Generic Input:
                                               const String& option,
                                               const String& species_tag,
                                               // Verbosity object:
                                               const Verbosity& verbosity);
 
 
void abs_lines_per_speciesPopulation(// WS Output: