auto_md.h

Go to the documentation of this file.

// This file was generated automatically by make_auto_md_h.cc.
// DO NOT EDIT !
// Generated: Oct 26 2021, 12:31:26
 
#ifndef auto_md_h
#define auto_md_h
 
#include "matpackI.h"
#include "matpackII.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 "transmissionmatrix.h"
#include "telsem.h"
#include "tessem.h"
#include "hitran_xsec.h"
#include "absorptionlines.h"
#include "linemixing.h"
 
// This is only used for a consistency check. You can get the
// number of WSMs from md_data.nelem().
#define N_MD 2070
 
// Method function declarations:
 
 
void AbsorptionLinesCreate(// WS Generic Output:
                           AbsorptionLines& out,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void AgendaCreate(// WS Generic Output:
                  Agenda& out,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void ArrayOfAbsorptionLinesCreate(// WS Generic Output:
                                  ArrayOfAbsorptionLines& out,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void ArrayOfArrayOfAbsorptionLinesCreate(// WS Generic Output:
                                         ArrayOfArrayOfAbsorptionLines& out,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void ArrayOfAgendaCreate(// WS Generic Output:
                         ArrayOfAgenda& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfArrayOfGriddedField1Create(// WS Generic Output:
                                       ArrayOfArrayOfGriddedField1& out,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void ArrayOfArrayOfGriddedField2Create(// WS Generic Output:
                                       ArrayOfArrayOfGriddedField2& out,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void ArrayOfArrayOfGriddedField3Create(// WS Generic Output:
                                       ArrayOfArrayOfGriddedField3& out,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void ArrayOfArrayOfIndexCreate(// WS Generic Output:
                               ArrayOfArrayOfIndex& out,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void ArrayOfArrayOfMatrixCreate(// WS Generic Output:
                                ArrayOfArrayOfMatrix& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfPpathCreate(// WS Generic Output:
                        ArrayOfPpath& out,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void ArrayOfArrayOfPropagationMatrixCreate(// WS Generic Output:
                                           ArrayOfArrayOfPropagationMatrix& out,
                                           // Verbosity object:
                                           const Verbosity& verbosity);
 
 
void ArrayOfArrayOfRadiationVectorCreate(// WS Generic Output:
                                         ArrayOfArrayOfRadiationVector& out,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void ArrayOfArrayOfScatteringMetaDataCreate(// WS Generic Output:
                                            ArrayOfArrayOfScatteringMetaData& out,
                                            // Verbosity object:
                                            const Verbosity& verbosity);
 
 
void ArrayOfArrayOfSingleScatteringDataCreate(// WS Generic Output:
                                              ArrayOfArrayOfSingleScatteringData& out,
                                              // Verbosity object:
                                              const Verbosity& verbosity);
 
 
void ArrayOfArrayOfSpeciesTagCreate(// WS Generic Output:
                                    ArrayOfArrayOfSpeciesTag& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void ArrayOfArrayOfStokesVectorCreate(// WS Generic Output:
                                      ArrayOfArrayOfStokesVector& out,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void ArrayOfArrayOfStringCreate(// WS Generic Output:
                                ArrayOfArrayOfString& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTensor3Create(// WS Generic Output:
                                 ArrayOfArrayOfTensor3& out,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTensor6Create(// WS Generic Output:
                                 ArrayOfArrayOfTensor6& out,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTimeCreate(// WS Generic Output:
                              ArrayOfArrayOfTime& out,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTransmissionMatrixCreate(// WS Generic Output:
                                            ArrayOfArrayOfTransmissionMatrix& out,
                                            // Verbosity object:
                                            const Verbosity& verbosity);
 
 
void ArrayOfArrayOfVectorCreate(// WS Generic Output:
                                ArrayOfArrayOfVector& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfCIARecordCreate(// WS Generic Output:
                            ArrayOfCIARecord& out,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void ArrayOfGriddedField1Create(// WS Generic Output:
                                ArrayOfGriddedField1& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfGriddedField2Create(// WS Generic Output:
                                ArrayOfGriddedField2& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfGriddedField3Create(// WS Generic Output:
                                ArrayOfGriddedField3& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfGriddedField4Create(// WS Generic Output:
                                ArrayOfGriddedField4& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfIndexCreate(// WS Generic Output:
                        ArrayOfIndex& out,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void ArrayOfJacobianTargetCreate(// WS Generic Output:
                                 ArrayOfJacobianTarget& out,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void ArrayOfMatrixCreate(// WS Generic Output:
                         ArrayOfMatrix& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfPropagationMatrixCreate(// WS Generic Output:
                                    ArrayOfPropagationMatrix& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void ArrayOfQuantumIdentifierCreate(// WS Generic Output:
                                    ArrayOfQuantumIdentifier& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void ArrayOfRadiationVectorCreate(// WS Generic Output:
                                  ArrayOfRadiationVector& out,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void ArrayOfRetrievalQuantityCreate(// WS Generic Output:
                                    ArrayOfRetrievalQuantity& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void ArrayOfScatteringMetaDataCreate(// WS Generic Output:
                                     ArrayOfScatteringMetaData& out,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void ArrayOfSingleScatteringDataCreate(// WS Generic Output:
                                       ArrayOfSingleScatteringData& out,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void ArrayOfSpeciesTagCreate(// WS Generic Output:
                             ArrayOfSpeciesTag& out,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfSparseCreate(// WS Generic Output:
                         ArrayOfSparse& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfStokesVectorCreate(// WS Generic Output:
                               ArrayOfStokesVector& out,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void ArrayOfStringCreate(// WS Generic Output:
                         ArrayOfString& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfTelsemAtlasCreate(// WS Generic Output:
                              ArrayOfTelsemAtlas& out,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void ArrayOfTensor3Create(// WS Generic Output:
                          ArrayOfTensor3& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfTensor4Create(// WS Generic Output:
                          ArrayOfTensor4& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfTensor5Create(// WS Generic Output:
                          ArrayOfTensor5& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfTensor6Create(// WS Generic Output:
                          ArrayOfTensor6& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfTensor7Create(// WS Generic Output:
                          ArrayOfTensor7& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfTimeCreate(// WS Generic Output:
                       ArrayOfTime& out,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void ArrayOfTransmissionMatrixCreate(// WS Generic Output:
                                     ArrayOfTransmissionMatrix& out,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void ArrayOfVectorCreate(// WS Generic Output:
                         ArrayOfVector& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfXsecRecordCreate(// WS Generic Output:
                             ArrayOfXsecRecord& out,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void CIARecordCreate(// WS Generic Output:
                     CIARecord& out,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CovarianceMatrixCreate(// WS Generic Output:
                            CovarianceMatrix& out,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void EnergyLevelMapCreate(// WS Generic Output:
                          EnergyLevelMap& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void GasAbsLookupCreate(// WS Generic Output:
                        GasAbsLookup& out,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void GridPosCreate(// WS Generic Output:
                   GridPos& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void GriddedField1Create(// WS Generic Output:
                         GriddedField1& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedField2Create(// WS Generic Output:
                         GriddedField2& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedField3Create(// WS Generic Output:
                         GriddedField3& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedField4Create(// WS Generic Output:
                         GriddedField4& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedField5Create(// WS Generic Output:
                         GriddedField5& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedField6Create(// WS Generic Output:
                         GriddedField6& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void HitranRelaxationMatrixDataCreate(// WS Generic Output:
                                      HitranRelaxationMatrixData& out,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void IndexCreate(// WS Generic Output:
                 Index& out,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void JacobianTargetCreate(// WS Generic Output:
                          JacobianTarget& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void MapOfErrorCorrectedSuddenDataCreate(// WS Generic Output:
                                         MapOfErrorCorrectedSuddenData& out,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void MCAntennaCreate(// WS Generic Output:
                     MCAntenna& out,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void MatrixCreate(// WS Generic Output:
                  Matrix& out,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void NumericCreate(// WS Generic Output:
                   Numeric& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void PpathCreate(// WS Generic Output:
                 Ppath& out,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void PropagationMatrixCreate(// WS Generic Output:
                             PropagationMatrix& out,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void QuantumIdentifierCreate(// WS Generic Output:
                             QuantumIdentifier& out,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void RadiationVectorCreate(// WS Generic Output:
                           RadiationVector& out,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void RationalCreate(// WS Generic Output:
                    Rational& out,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void ScatteringMetaDataCreate(// WS Generic Output:
                              ScatteringMetaData& out,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void SingleScatteringDataCreate(// WS Generic Output:
                                SingleScatteringData& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void SparseCreate(// WS Generic Output:
                  Sparse& out,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void SpeciesIsotopologueRatiosCreate(// WS Generic Output:
                                     SpeciesIsotopologueRatios& out,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void StokesVectorCreate(// WS Generic Output:
                        StokesVector& out,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void StringCreate(// WS Generic Output:
                  String& out,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void TelsemAtlasCreate(// WS Generic Output:
                       TelsemAtlas& out,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void Tensor3Create(// WS Generic Output:
                   Tensor3& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Tensor4Create(// WS Generic Output:
                   Tensor4& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Tensor5Create(// WS Generic Output:
                   Tensor5& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Tensor6Create(// WS Generic Output:
                   Tensor6& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Tensor7Create(// WS Generic Output:
                   Tensor7& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void TimerCreate(// WS Generic Output:
                 Timer& out,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void TimeCreate(// WS Generic Output:
                Time& out,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void TessemNNCreate(// WS Generic Output:
                    TessemNN& out,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void TransmissionMatrixCreate(// WS Generic Output:
                              TransmissionMatrix& out,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void VectorCreate(// WS Generic Output:
                  Vector& out,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void VerbosityCreate(// WS Generic Output:
                     Verbosity& out,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void AbsInputFromAtmFields(// WS Output:
                           Vector& abs_p,
                           Vector& abs_t,
                           Matrix& abs_vmrs,
                           // WS Input:
                           const Index& atmosphere_dim,
                           const Vector& p_grid,
                           const Tensor3& t_field,
                           const Tensor4& vmr_field,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void 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_cont_descriptionAppend(// WS Output:
                                ArrayOfString& abs_cont_names,
                                ArrayOfString& abs_cont_models,
                                ArrayOfVector& abs_cont_parameters,
                                // WS Generic Input:
                                const String& tagname,
                                const String& model,
                                const Vector& userparam,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void abs_cont_descriptionInit(// WS Output:
                              ArrayOfString& abs_cont_names,
                              ArrayOfString& abs_cont_models,
                              ArrayOfVector& abs_cont_parameters,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void abs_hitran_relmat_dataReadHitranRelmatDataAndLines(// WS Output:
                                                        HitranRelaxationMatrixData& abs_hitran_relmat_data,
                                                        ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                        // WS Input:
                                                        const ArrayOfArrayOfSpeciesTag& abs_species,
                                                        // WS Generic Input:
                                                        const String& basedir,
                                                        const Numeric& linemixinglimit,
                                                        const Numeric& fmin,
                                                        const Numeric& fmax,
                                                        const Numeric& stot,
                                                        const String& mode,
                                                        const String& hitran_type,
                                                        // 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_speciesHitranLineMixingAdaptationData(// WS Generic Output:
                                                         ArrayOfTensor5& lm_data,
                                                         // WS Input:
                                                         const ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                         const HitranRelaxationMatrixData& abs_hitran_relmat_data,
                                                         // WS Generic Input:
                                                         const Vector& t_grid,
                                                         const Vector& p_grid,
                                                         // 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_linesRemoveBand(// WS Output:
                         ArrayOfAbsorptionLines& abs_lines,
                         // WS Generic Input:
                         const QuantumIdentifier& qid,
                         // 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,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void abs_lines_per_speciesRemoveLines(// WS Output:
                                      ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                      // WS Generic Input:
                                      const Numeric& lower_frequency,
                                      const Numeric& upper_frequency,
                                      const Numeric& lower_intensity,
                                      const Index& safe,
                                      // 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,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void abs_lines_per_speciesRemoveLinesFromSpecies(// WS Output:
                                                 ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                 // WS Generic Input:
                                                 const ArrayOfSpeciesTag& species,
                                                 const Numeric& lower_frequency,
                                                 const Numeric& upper_frequency,
                                                 const Numeric& lower_intensity,
                                                 const Index& safe,
                                                 // Verbosity object:
                                                 const Verbosity& verbosity);
 
 
void abs_linesRemoveEmptyBands(// 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_lines_per_speciesFlatten(// WS Output:
                                  ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void abs_linesRemoveUnusedLocalQuantumNumbers(// WS Output:
                                              ArrayOfAbsorptionLines& abs_lines,
                                              // Verbosity object:
                                              const Verbosity& verbosity);
 
 
void abs_linesReplaceWithLines(// WS Output:
                               ArrayOfAbsorptionLines& abs_lines,
                               // WS Generic Input:
                               const ArrayOfAbsorptionLines& replacing_lines,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void abs_linesAppendWithLines(// WS Output:
                              ArrayOfAbsorptionLines& abs_lines,
                              // WS Generic Input:
                              const ArrayOfAbsorptionLines& appending_lines,
                              const Index& safe,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void abs_linesDeleteWithLines(// WS Output:
                              ArrayOfAbsorptionLines& abs_lines,
                              // WS Generic Input:
                              const ArrayOfAbsorptionLines& deleting_lines,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void abs_linesDeleteBadF0(// WS Output:
                          ArrayOfAbsorptionLines& abs_lines,
                          // WS Generic Input:
                          const Numeric& f0,
                          const Index& lower,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void abs_linesDeleteLinesWithUndefinedLocalQuanta(// WS Output:
                                                  ArrayOfAbsorptionLines& abs_lines,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);
 
 
void abs_linesDeleteLinesWithBadOrHighChangingJs(// WS Output:
                                                 ArrayOfAbsorptionLines& abs_lines,
                                                 // Verbosity object:
                                                 const Verbosity& verbosity);
 
 
void abs_linesDeleteLinesWithQuantumNumberAbove(// WS Output:
                                                ArrayOfAbsorptionLines& abs_lines,
                                                // WS Generic Input:
                                                const String& quantumnumber,
                                                const Index& quantumnumber_value,
                                                // Verbosity object:
                                                const Verbosity& verbosity);
 
 
void abs_linesPrintDefinedQuantumNumbers(// WS Input:
                                         const ArrayOfAbsorptionLines& abs_lines,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void abs_lines_per_speciesReadSplitCatalog(// WS Output:
                                           ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                           // WS Input:
                                           const ArrayOfArrayOfSpeciesTag& abs_species,
                                           // WS Generic Input:
                                           const String& basename,
                                           // Verbosity object:
                                           const Verbosity& verbosity);
 
 
void abs_linesReadSpeciesSplitCatalog(// WS Output:
                                      ArrayOfAbsorptionLines& abs_lines,
                                      // WS Generic Input:
                                      const String& basename,
                                      const Index& robust,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void abs_lines_per_speciesReadSpeciesSplitCatalog(// WS Output:
                                                  ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                  // WS Input:
                                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                                  // WS Generic Input:
                                                  const String& basename,
                                                  const Index& robust,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetEmpty(// WS Output:
                                   ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                   // WS Input:
                                   const ArrayOfArrayOfSpeciesTag& abs_species,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void abs_linesSetEmptyBroadeningParametersToEmpty(// WS Output:
                                                  ArrayOfAbsorptionLines& abs_lines,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);
 
 
void abs_linesSetNormalization(// WS Output:
                               ArrayOfAbsorptionLines& abs_lines,
                               // WS Generic Input:
                               const String& option,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetNormalization(// WS Output:
                                           ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                           // WS Generic Input:
                                           const String& option,
                                           // Verbosity object:
                                           const Verbosity& verbosity);
 
 
void abs_linesSetNormalizationForMatch(// WS Output:
                                       ArrayOfAbsorptionLines& abs_lines,
                                       // WS Generic Input:
                                       const String& option,
                                       const QuantumIdentifier& ID,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetNormalizationForMatch(// WS Output:
                                                   ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                   // WS Generic Input:
                                                   const String& option,
                                                   const QuantumIdentifier& ID,
                                                   // Verbosity object:
                                                   const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetNormalizationForSpecies(// WS Output:
                                                     ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                     // WS Input:
                                                     const ArrayOfArrayOfSpeciesTag& abs_species,
                                                     // WS Generic Input:
                                                     const String& option,
                                                     const String& species_tag,
                                                     // Verbosity object:
                                                     const Verbosity& verbosity);
 
 
void abs_linesSetMirroring(// WS Output:
                           ArrayOfAbsorptionLines& abs_lines,
                           // WS Generic Input:
                           const String& option,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetMirroring(// WS Output:
                                       ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                       // WS Generic Input:
                                       const String& option,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void abs_linesSetMirroringForMatch(// WS Output:
                                   ArrayOfAbsorptionLines& abs_lines,
                                   // WS Generic Input:
                                   const String& option,
                                   const QuantumIdentifier& ID,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetMirroringForMatch(// WS Output:
                                               ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                               // WS Generic Input:
                                               const String& option,
                                               const QuantumIdentifier& ID,
                                               // Verbosity object:
                                               const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetMirroringForSpecies(// WS Output:
                                                 ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                 // WS Input:
                                                 const ArrayOfArrayOfSpeciesTag& abs_species,
                                                 // WS Generic Input:
                                                 const String& option,
                                                 const String& species_tag,
                                                 // Verbosity object:
                                                 const Verbosity& verbosity);
 
 
void abs_linesMakeManualMirroring(// WS Output:
                                  ArrayOfAbsorptionLines& abs_lines,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void abs_lines_per_speciesMakeManualMirroring(// WS Output:
                                              ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                              // Verbosity object:
                                              const Verbosity& verbosity);
 
 
void abs_lines_per_speciesMakeManualMirroringSpecies(// 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_linesSetPopulation(// WS Output:
                            ArrayOfAbsorptionLines& abs_lines,
                            // WS Generic Input:
                            const String& option,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetPopulation(// WS Output:
                                        ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                        // WS Generic Input:
                                        const String& option,
                                        // Verbosity object:
                                        const Verbosity& verbosity);
 
 
void abs_linesSetPopulationForMatch(// WS Output:
                                    ArrayOfAbsorptionLines& abs_lines,
                                    // WS Generic Input:
                                    const String& option,
                                    const QuantumIdentifier& ID,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetPopulationForMatch(// WS Output:
                                                ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                // WS Generic Input:
                                                const String& option,
                                                const QuantumIdentifier& ID,
                                                // Verbosity object:
                                                const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetPopulationForSpecies(// WS Output:
                                                  ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                  // WS Input:
                                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                                  // WS Generic Input:
                                                  const String& option,
                                                  const String& species_tag,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);
 
 
void abs_linesSetLineShapeType(// WS Output:
                               ArrayOfAbsorptionLines& abs_lines,
                               // WS Generic Input:
                               const String& option,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetLineShapeType(// WS Output:
                                           ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                           // WS Generic Input:
                                           const String& option,
                                           // Verbosity object:
                                           const Verbosity& verbosity);
 
 
void abs_linesSetLineShapeTypeForMatch(// WS Output:
                                       ArrayOfAbsorptionLines& abs_lines,
                                       // WS Generic Input:
                                       const String& option,
                                       const QuantumIdentifier& ID,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetLineShapeTypeForMatch(// WS Output:
                                                   ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                   // WS Generic Input:
                                                   const String& option,
                                                   const QuantumIdentifier& ID,
                                                   // Verbosity object:
                                                   const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetLineShapeTypeForSpecies(// WS Output:
                                                     ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                     // WS Input:
                                                     const ArrayOfArrayOfSpeciesTag& abs_species,
                                                     // WS Generic Input:
                                                     const String& option,
                                                     const String& species_tag,
                                                     // Verbosity object:
                                                     const Verbosity& verbosity);
 
 
void abs_linesSetCutoff(// WS Output:
                        ArrayOfAbsorptionLines& abs_lines,
                        // WS Generic Input:
                        const String& option,
                        const Numeric& value,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetCutoff(// WS Output:
                                    ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                    // WS Generic Input:
                                    const String& option,
                                    const Numeric& value,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void abs_linesSetCutoffForMatch(// WS Output:
                                ArrayOfAbsorptionLines& abs_lines,
                                // WS Generic Input:
                                const String& option,
                                const Numeric& value,
                                const QuantumIdentifier& ID,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetCutoffForMatch(// WS Output:
                                            ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                            // WS Generic Input:
                                            const String& option,
                                            const Numeric& value,
                                            const QuantumIdentifier& ID,
                                            // Verbosity object:
                                            const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetCutoffForSpecies(// WS Output:
                                              ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                              // WS Input:
                                              const ArrayOfArrayOfSpeciesTag& abs_species,
                                              // WS Generic Input:
                                              const String& option,
                                              const Numeric& value,
                                              const String& species_tag,
                                              // Verbosity object:
                                              const Verbosity& verbosity);
 
 
void abs_linesSetLinemixingLimit(// WS Output:
                                 ArrayOfAbsorptionLines& abs_lines,
                                 // WS Generic Input:
                                 const Numeric& value,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetLinemixingLimit(// WS Output:
                                             ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                             // WS Generic Input:
                                             const Numeric& value,
                                             // Verbosity object:
                                             const Verbosity& verbosity);
 
 
void abs_linesSetLinemixingLimitForMatch(// WS Output:
                                         ArrayOfAbsorptionLines& abs_lines,
                                         // WS Generic Input:
                                         const Numeric& value,
                                         const QuantumIdentifier& ID,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetLinemixingLimitForMatch(// WS Output:
                                                     ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                     // WS Generic Input:
                                                     const Numeric& value,
                                                     const QuantumIdentifier& ID,
                                                     // Verbosity object:
                                                     const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetLinemixingLimitForSpecies(// WS Output:
                                                       ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                       // WS Input:
                                                       const ArrayOfArrayOfSpeciesTag& abs_species,
                                                       // WS Generic Input:
                                                       const Numeric& value,
                                                       const String& species_tag,
                                                       // Verbosity object:
                                                       const Verbosity& verbosity);
 
 
void abs_linesSetT0(// WS Output:
                    ArrayOfAbsorptionLines& abs_lines,
                    // WS Generic Input:
                    const Numeric& value,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetT0(// WS Output:
                                ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                // WS Generic Input:
                                const Numeric& value,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void abs_linesSetT0ForMatch(// WS Output:
                            ArrayOfAbsorptionLines& abs_lines,
                            // WS Generic Input:
                            const Numeric& value,
                            const QuantumIdentifier& ID,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetT0ForMatch(// WS Output:
                                        ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                        // WS Generic Input:
                                        const Numeric& value,
                                        const QuantumIdentifier& ID,
                                        // Verbosity object:
                                        const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetT0ForSpecies(// WS Output:
                                          ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                          // WS Input:
                                          const ArrayOfArrayOfSpeciesTag& abs_species,
                                          // WS Generic Input:
                                          const Numeric& value,
                                          const String& species_tag,
                                          // Verbosity object:
                                          const Verbosity& verbosity);
 
 
void abs_linesSetQuantumNumberForMatch(// WS Output:
                                       ArrayOfAbsorptionLines& abs_lines,
                                       // WS Generic Input:
                                       const String& quantum_number,
                                       const Rational& value,
                                       const QuantumIdentifier& ID,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetQuantumNumberForMatch(// WS Output:
                                                   ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                   // WS Generic Input:
                                                   const String& quantum_number,
                                                   const Rational& value,
                                                   const QuantumIdentifier& ID,
                                                   // Verbosity object:
                                                   const Verbosity& verbosity);
 
 
void abs_linesChangeBaseParameterForMatchingLevel(// WS Output:
                                                  ArrayOfAbsorptionLines& abs_lines,
                                                  // WS Generic Input:
                                                  const QuantumIdentifier& QI,
                                                  const String& parameter_name,
                                                  const Numeric& change,
                                                  const Index& relative,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);
 
 
void abs_linesChangeBaseParameterForMatchingLevels(// WS Output:
                                                   ArrayOfAbsorptionLines& abs_lines,
                                                   // WS Generic Input:
                                                   const ArrayOfQuantumIdentifier& QI,
                                                   const String& parameter_name,
                                                   const Vector& change,
                                                   const Index& relative,
                                                   // Verbosity object:
                                                   const Verbosity& verbosity);
 
 
void abs_lines_per_speciesChangeBaseParameterForMatchingLevel(// WS Output:
                                                              ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                              // WS Generic Input:
                                                              const QuantumIdentifier& QI,
                                                              const String& parameter_name,
                                                              const Numeric& change,
                                                              const Index& relative,
                                                              // Verbosity object:
                                                              const Verbosity& verbosity);
 
 
void abs_lines_per_speciesChangeBaseParameterForMatchingLevels(// WS Output:
                                                               ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                               // WS Generic Input:
                                                               const ArrayOfQuantumIdentifier& QI,
                                                               const String& parameter_name,
                                                               const Vector& change,
                                                               const Index& relative,
                                                               // Verbosity object:
                                                               const Verbosity& verbosity);
 
 
void abs_linesSetBaseParameterForMatchingLevel(// WS Output:
                                               ArrayOfAbsorptionLines& abs_lines,
                                               // WS Generic Input:
                                               const QuantumIdentifier& QI,
                                               const String& parameter_name,
                                               const Numeric& change,
                                               // Verbosity object:
                                               const Verbosity& verbosity);
 
 
void abs_linesSetBaseParameterForMatchingLevels(// WS Output:
                                                ArrayOfAbsorptionLines& abs_lines,
                                                // WS Generic Input:
                                                const ArrayOfQuantumIdentifier& QI,
                                                const String& parameter_name,
                                                const Vector& change,
                                                // Verbosity object:
                                                const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetBaseParameterForMatchingLevel(// WS Output:
                                                           ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                           // WS Generic Input:
                                                           const QuantumIdentifier& QI,
                                                           const String& parameter_name,
                                                           const Numeric& change,
                                                           // Verbosity object:
                                                           const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetBaseParameterForMatchingLevels(// WS Output:
                                                            ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                            // WS Generic Input:
                                                            const ArrayOfQuantumIdentifier& QI,
                                                            const String& parameter_name,
                                                            const Vector& change,
                                                            // Verbosity object:
                                                            const Verbosity& verbosity);
 
 
void abs_linesChangeBaseParameterForMatchingLines(// WS Output:
                                                  ArrayOfAbsorptionLines& abs_lines,
                                                  // WS Generic Input:
                                                  const QuantumIdentifier& QI,
                                                  const String& parameter_name,
                                                  const Numeric& change,
                                                  const Index& relative,
                                                  const Index& band_matching,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);
 
 
void abs_lines_per_speciesChangeBaseParameterForMatchingLines(// WS Output:
                                                              ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                              // WS Generic Input:
                                                              const QuantumIdentifier& QI,
                                                              const String& parameter_name,
                                                              const Numeric& change,
                                                              const Index& relative,
                                                              const Index& band_matching,
                                                              // Verbosity object:
                                                              const Verbosity& verbosity);
 
 
void abs_lines_per_speciesChangeBaseParameterForSpecies(// WS Output:
                                                        ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                        // WS Input:
                                                        const ArrayOfArrayOfSpeciesTag& abs_species,
                                                        // WS Generic Input:
                                                        const QuantumIdentifier& QI,
                                                        const String& parameter_name,
                                                        const Numeric& change,
                                                        const Index& relative,
                                                        const Index& band_matching,
                                                        const String& species_tag,
                                                        // Verbosity object:
                                                        const Verbosity& verbosity);
 
 
void abs_linesSetBaseParameterForMatchingLines(// WS Output:
                                               ArrayOfAbsorptionLines& abs_lines,
                                               // WS Generic Input:
                                               const QuantumIdentifier& QI,
                                               const String& parameter_name,
                                               const Numeric& change,
                                               const Index& band_matching,
                                               // Verbosity object:
                                               const Verbosity& verbosity);
 
 
void abs_linesSetLineShapeModelParametersForMatchingLines(// 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_lines_per_speciesSetLineShapeModelParametersForMatchingLines(// 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_linesSetZeemanCoefficients(// WS Output:
                                    ArrayOfAbsorptionLines& abs_lines,
                                    // WS Generic Input:
                                    const ArrayOfQuantumIdentifier& qid,
                                    const Vector& gs,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetZeemanCoefficients(// WS Output:
                                                ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                // WS Generic Input:
                                                const ArrayOfQuantumIdentifier& qid,
                                                const Vector& gs,
                                                // Verbosity object:
                                                const Verbosity& verbosity);
 
 
void abs_linesCompact(// WS Output:
                      ArrayOfAbsorptionLines& abs_lines,
                      // WS Input:
                      const Vector& f_grid,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void abs_lines_per_speciesCompact(// WS Output:
                                  ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                  // WS Input:
                                  const Vector& f_grid,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void abs_lines_per_speciesCreateFromLines(// WS Output:
                                          ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                          // WS Input:
                                          const ArrayOfAbsorptionLines& abs_lines,
                                          const ArrayOfArrayOfSpeciesTag& abs_species,
                                          // Verbosity object:
                                          const Verbosity& verbosity);
 
 
void abs_lookupAdapt(// WS Output:
                     GasAbsLookup& abs_lookup,
                     Index& abs_lookup_is_adapted,
                     // WS Input:
                     const ArrayOfArrayOfSpeciesTag& abs_species,
                     const Vector& f_grid,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void abs_lookupCalc(// Workspace reference:
                    Workspace& ws,
                    // WS Output:
                    GasAbsLookup& abs_lookup,
                    Index& abs_lookup_is_adapted,
                    // WS Input:
                    const ArrayOfArrayOfSpeciesTag& abs_species,
                    const ArrayOfArrayOfSpeciesTag& abs_nls,
                    const Vector& f_grid,
                    const Vector& abs_p,
                    const Matrix& abs_vmrs,
                    const Vector& abs_t,
                    const Vector& abs_t_pert,
                    const Vector& abs_nls_pert,
                    const Agenda& abs_xsec_agenda,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void abs_lookupInit(// WS Output:
                    GasAbsLookup& abs_lookup,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void abs_lookupSetup(// WS Output:
                     Vector& abs_p,
                     Vector& abs_t,
                     Vector& abs_t_pert,
                     Matrix& abs_vmrs,
                     ArrayOfArrayOfSpeciesTag& abs_nls,
                     Vector& abs_nls_pert,
                     // WS Input:
                     const Index& atmosphere_dim,
                     const Vector& p_grid,
                     const Tensor3& t_field,
                     const Tensor4& vmr_field,
                     const Index& atmfields_checked,
                     const ArrayOfArrayOfSpeciesTag& abs_species,
                     const Index& abs_p_interp_order,
                     const Index& abs_t_interp_order,
                     const Index& abs_nls_interp_order,
                     // WS Generic Input:
                     const Numeric& p_step,
                     const Numeric& t_step,
                     const Numeric& h2o_step,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void abs_lookupSetupBatch(// WS Output:
                          Vector& abs_p,
                          Vector& abs_t,
                          Vector& abs_t_pert,
                          Matrix& abs_vmrs,
                          ArrayOfArrayOfSpeciesTag& abs_nls,
                          Vector& abs_nls_pert,
                          // WS Input:
                          const ArrayOfArrayOfSpeciesTag& abs_species,
                          const ArrayOfGriddedField4& batch_atm_fields_compact,
                          const Index& abs_p_interp_order,
                          const Index& abs_t_interp_order,
                          const Index& abs_nls_interp_order,
                          const Index& atmosphere_dim,
                          // WS Generic Input:
                          const Numeric& p_step,
                          const Numeric& t_step,
                          const Numeric& h2o_step,
                          const Vector& extremes,
                          const Index& robust,
                          const Index& check_gridnames,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void abs_lookupSetupWide(// WS Output:
                         Vector& abs_p,
                         Vector& abs_t,
                         Vector& abs_t_pert,
                         Matrix& abs_vmrs,
                         ArrayOfArrayOfSpeciesTag& abs_nls,
                         Vector& abs_nls_pert,
                         // WS Input:
                         const ArrayOfArrayOfSpeciesTag& abs_species,
                         const Index& abs_p_interp_order,
                         const Index& abs_t_interp_order,
                         const Index& abs_nls_interp_order,
                         // WS Generic Input:
                         const Numeric& p_min,
                         const Numeric& p_max,
                         const Numeric& p_step,
                         const Numeric& t_min,
                         const Numeric& t_max,
                         const Numeric& h2o_min,
                         const Numeric& h2o_max,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void abs_lookupTestAccuracy(// Workspace reference:
                            Workspace& ws,
                            // WS Input:
                            const GasAbsLookup& abs_lookup,
                            const Index& abs_lookup_is_adapted,
                            const Index& abs_p_interp_order,
                            const Index& abs_t_interp_order,
                            const Index& abs_nls_interp_order,
                            const Agenda& abs_xsec_agenda,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void abs_lookupTestAccMC(// Workspace reference:
                         Workspace& ws,
                         // WS Input:
                         const GasAbsLookup& abs_lookup,
                         const Index& abs_lookup_is_adapted,
                         const Index& abs_p_interp_order,
                         const Index& abs_t_interp_order,
                         const Index& abs_nls_interp_order,
                         const Index& mc_seed,
                         const Agenda& abs_xsec_agenda,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void abs_nlteFromRaw(// WS Output:
                     EnergyLevelMap& abs_nlte,
                     // WS Input:
                     const ArrayOfQuantumIdentifier& nlte_level_identifiers,
                     const Vector& nlte_vibrational_energies,
                     // WS Generic Input:
                     const Matrix& data,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void abs_speciesAdd(// WS Output:
                    ArrayOfArrayOfSpeciesTag& abs_species,
                    Index& propmat_clearsky_agenda_checked,
                    Index& abs_xsec_agenda_checked,
                    // WS Generic Input:
                    const ArrayOfString& species,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void abs_speciesAdd2(// Workspace reference:
                     Workspace& ws,
                     // WS Output:
                     ArrayOfArrayOfSpeciesTag& abs_species,
                     ArrayOfRetrievalQuantity& jacobian_quantities,
                     Agenda& jacobian_agenda,
                     Index& propmat_clearsky_agenda_checked,
                     Index& abs_xsec_agenda_checked,
                     // WS Input:
                     const Index& atmosphere_dim,
                     const Vector& p_grid,
                     const Vector& lat_grid,
                     const Vector& lon_grid,
                     // WS Generic Input:
                     const Vector& gin1,
                     const Vector& gin2,
                     const Vector& gin3,
                     const String& species,
                     const String& unit,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void abs_speciesDefineAllInScenario(// WS Output:
                                    ArrayOfArrayOfSpeciesTag& abs_species,
                                    Index& propmat_clearsky_agenda_checked,
                                    Index& abs_xsec_agenda_checked,
                                    // WS Generic Input:
                                    const String& basename,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void abs_speciesDefineAll(// WS Output:
                          ArrayOfArrayOfSpeciesTag& abs_species,
                          Index& propmat_clearsky_agenda_checked,
                          Index& abs_xsec_agenda_checked,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void abs_speciesInit(// WS Output:
                     ArrayOfArrayOfSpeciesTag& abs_species,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void abs_speciesSet(// WS Output:
                    ArrayOfArrayOfSpeciesTag& abs_species,
                    Index& abs_xsec_agenda_checked,
                    Index& propmat_clearsky_agenda_checked,
                    // WS Generic Input:
                    const ArrayOfString& species,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void abs_vecAddGas(// WS Output:
                   StokesVector& abs_vec,
                   // WS Input:
                   const PropagationMatrix& propmat_clearsky,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void abs_xsec_agenda_checkedCalc(// Workspace reference:
                                 Workspace& ws,
                                 // WS Output:
                                 Index& abs_xsec_agenda_checked,
                                 // WS Input:
                                 const ArrayOfArrayOfSpeciesTag& abs_species,
                                 const Agenda& abs_xsec_agenda,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void abs_xsec_per_speciesAddCIA(// WS Output:
                                ArrayOfMatrix& abs_xsec_per_species,
                                ArrayOfArrayOfMatrix& dabs_xsec_per_species_dx,
                                // WS Input:
                                const ArrayOfArrayOfSpeciesTag& abs_species,
                                const ArrayOfRetrievalQuantity& jacobian_quantities,
                                const ArrayOfIndex& abs_species_active,
                                const Vector& f_grid,
                                const Vector& abs_p,
                                const Vector& abs_t,
                                const Matrix& abs_vmrs,
                                const ArrayOfCIARecord& abs_cia_data,
                                // WS Generic Input:
                                const Numeric& T_extrapolfac,
                                const Index& robust,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void abs_xsec_per_speciesAddHitranXsec(// WS Output:
                                       ArrayOfMatrix& abs_xsec_per_species,
                                       ArrayOfArrayOfMatrix& dabs_xsec_per_species_dx,
                                       // WS Input:
                                       const ArrayOfArrayOfSpeciesTag& abs_species,
                                       const ArrayOfRetrievalQuantity& jacobian_quantities,
                                       const ArrayOfIndex& abs_species_active,
                                       const Vector& f_grid,
                                       const Vector& abs_p,
                                       const Vector& abs_t,
                                       const ArrayOfXsecRecord& hitran_xsec_data,
                                       // WS Generic Input:
                                       const Index& apply_tfit,
                                       const Numeric& force_p,
                                       const Numeric& force_t,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void abs_xsec_per_speciesAddConts(// WS Output:
                                  ArrayOfMatrix& abs_xsec_per_species,
                                  ArrayOfArrayOfMatrix& dabs_xsec_per_species_dx,
                                  // WS Input:
                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                  const ArrayOfRetrievalQuantity& jacobian_quantities,
                                  const ArrayOfIndex& abs_species_active,
                                  const Vector& f_grid,
                                  const Vector& abs_p,
                                  const Vector& abs_t,
                                  const Matrix& abs_vmrs,
                                  const ArrayOfString& abs_cont_names,
                                  const ArrayOfVector& abs_cont_parameters,
                                  const ArrayOfString& abs_cont_models,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void abs_xsec_per_speciesAddLines(// WS Output:
                                  ArrayOfMatrix& abs_xsec_per_species,
                                  ArrayOfArrayOfMatrix& dabs_xsec_per_species_dx,
                                  // WS Input:
                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                  const ArrayOfRetrievalQuantity& jacobian_quantities,
                                  const ArrayOfIndex& abs_species_active,
                                  const Vector& f_grid,
                                  const Vector& abs_p,
                                  const Vector& abs_t,
                                  const Matrix& abs_vmrs,
                                  const ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                  const SpeciesIsotopologueRatios& isotopologue_ratios,
                                  const Index& lbl_checked,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void propmat_clearskyAddPredefinedO2MPM2020(// WS Output:
                                            PropagationMatrix& propmat_clearsky,
                                            ArrayOfPropagationMatrix& dpropmat_clearsky_dx,
                                            // WS Input:
                                            const ArrayOfArrayOfSpeciesTag& abs_species,
                                            const ArrayOfRetrievalQuantity& jacobian_quantities,
                                            const Vector& f_grid,
                                            const Numeric& rtp_pressure,
                                            const Numeric& rtp_temperature,
                                            const Vector& rtp_vmr,
                                            // Verbosity object:
                                            const Verbosity& verbosity);
 
 
void abs_xsec_per_speciesInit(// WS Output:
                              ArrayOfMatrix& abs_xsec_per_species,
                              ArrayOfArrayOfMatrix& dabs_xsec_per_species_dx,
                              // WS Input:
                              const ArrayOfArrayOfSpeciesTag& abs_species,
                              const ArrayOfRetrievalQuantity& jacobian_quantities,
                              const ArrayOfIndex& abs_species_active,
                              const Vector& f_grid,
                              const Vector& abs_p,
                              const Index& abs_xsec_agenda_checked,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void AddZaAa(// WS Generic Output:
             Matrix& new_los,
             // WS Generic Input:
             const Vector& ref_los,
             const Matrix& dlos,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void AgendaAppend(// Workspace reference:
                  Workspace& ws,
                  // WS Generic Output:
                  Agenda& out,
                  // WS Generic Output Names:
                  const String& out_wsvname,
                  // WS Generic Input:
                  const Agenda& in,
                  // WS Generic Input Names:
                  const String& in_wsvname,
                  // Agenda from controlfile:
                  const Agenda& input_agenda,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void AgendaExecute(// Workspace reference:
                   Workspace& ws,
                   // WS Generic Input:
                   const Agenda& a,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void AgendaExecuteExclusive(// Workspace reference:
                            Workspace& ws,
                            // WS Generic Input:
                            const Agenda& a,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void AgendaSet(// Workspace reference:
               Workspace& ws,
               // WS Generic Output:
               Agenda& out,
               // WS Generic Output Names:
               const String& out_wsvname,
               // Agenda from controlfile:
               const Agenda& input_agenda,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void AngularGridsSetFluxCalc(// WS Output:
                             Vector& za_grid,
                             Vector& aa_grid,
                             Vector& za_grid_weights,
                             // WS Generic Input:
                             const Index& N_za_grid,
                             const Index& N_aa_grid,
                             const String& za_grid_type,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfAgendaAppend(// Workspace reference:
                         Workspace& ws,
                         // WS Generic Output:
                         ArrayOfAgenda& out,
                         // WS Generic Output Names:
                         const String& out_wsvname,
                         // Agenda from controlfile:
                         const Agenda& input_agenda,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfAgendaExecute(// Workspace reference:
                          Workspace& ws,
                          // WS Input:
                          const Index& agenda_array_index,
                          // WS Generic Input:
                          const ArrayOfAgenda& agendas,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void AntennaConstantGaussian1D(// WS Output:
                               Index& antenna_dim,
                               Matrix& mblock_dlos_grid,
                               GriddedField4& antenna_response,
                               Matrix& antenna_dlos,
                               // WS Generic Input:
                               const Index& n_za_grid,
                               const Numeric& fwhm,
                               const Numeric& xwidth_si,
                               const Numeric& dx_si,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void AntennaMultiBeamsToPencilBeams(// WS Output:
                                    Matrix& sensor_pos,
                                    Matrix& sensor_los,
                                    Matrix& antenna_dlos,
                                    Index& antenna_dim,
                                    Matrix& mblock_dlos_grid,
                                    // WS Input:
                                    const Index& atmosphere_dim,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void AntennaOff(// WS Output:
                Index& antenna_dim,
                Matrix& mblock_dlos_grid,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void antenna_responseGaussian(// WS Output:
                              GriddedField4& antenna_response,
                              // WS Generic Input:
                              const Numeric& fwhm,
                              const Numeric& xwidth_si,
                              const Numeric& dx_si,
                              const Index& do_2d,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void antenna_responseVaryingGaussian(// WS Output:
                                     GriddedField4& antenna_response,
                                     // WS Generic Input:
                                     const Numeric& leff,
                                     const Numeric& xwidth_si,
                                     const Numeric& dx_si,
                                     const Index& nf,
                                     const Numeric& fstart,
                                     const Numeric& fstop,
                                     const Index& do_2d,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void ArrayOfIndexLinSpace(// WS Generic Output:
                          ArrayOfIndex& out,
                          // WS Generic Input:
                          const Index& start,
                          const Index& stop,
                          const Index& step,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfIndexSet(// WS Generic Output:
                     ArrayOfIndex& out,
                     // WS Generic Input:
                     const ArrayOfIndex& value,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void ArrayOfSpeciesTagSet(// WS Generic Output:
                          ArrayOfSpeciesTag& out,
                          // WS Generic Input:
                          const ArrayOfSpeciesTag& value,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfIndexSetConstant(// WS Generic Output:
                             ArrayOfIndex& out,
                             // WS Input:
                             const Index& nelem,
                             // WS Generic Input:
                             const Index& value,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfStringSet(// WS Generic Output:
                      ArrayOfString& out,
                      // WS Generic Input:
                      const ArrayOfString& value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void 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 ArrayOfTimeSetConstant(// WS Generic Output:
                            ArrayOfTime& out,
                            // WS Input:
                            const Index& nelem,
                            // WS Generic Input:
                            const Time& value,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void Arts(// Workspace reference:
          Workspace& ws,
          // Agenda from controlfile:
          const Agenda& input_agenda,
          // Verbosity object:
          const Verbosity& verbosity);
 
 
void Arts2(// Workspace reference:
           Workspace& ws,
           // Agenda from controlfile:
           const Agenda& input_agenda,
           // Verbosity object:
           const Verbosity& verbosity);
 
 
void AtmFieldPerturb(// WS Generic Output:
                     Tensor3& perturbed_field,
                     // WS Input:
                     const Index& atmosphere_dim,
                     const Vector& p_grid,
                     const Vector& lat_grid,
                     const Vector& lon_grid,
                     // WS Generic Input:
                     const Tensor3& original_field,
                     const Vector& p_ret_grid,
                     const Vector& lat_ret_grid,
                     const Vector& lon_ret_grid,
                     const Index& pert_index,
                     const Numeric& pert_size,
                     const String& pert_mode,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void AtmFieldPerturbAtmGrids(// WS Generic Output:
                             Tensor3& perturbed_field,
                             // WS Input:
                             const Index& atmosphere_dim,
                             const Vector& p_grid,
                             const Vector& lat_grid,
                             const Vector& lon_grid,
                             // WS Generic Input:
                             const Tensor3& original_field,
                             const Index& pert_index,
                             const Numeric& pert_size,
                             const String& pert_mode,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void AtmFieldPRegrid(// WS Generic Output:
                     Tensor3& out,
                     // WS Generic Input:
                     const Tensor3& in,
                     const Vector& p_grid_new,
                     const Vector& p_grid_old,
                     const Index& interp_order,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void AtmFieldPRegrid(// WS Generic Output:
                     Tensor4& out,
                     // WS Generic Input:
                     const Tensor4& in,
                     const Vector& p_grid_new,
                     const Vector& p_grid_old,
                     const Index& interp_order,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void AtmFieldsCalc(// WS Output:
                   Tensor3& t_field,
                   Tensor3& z_field,
                   Tensor4& vmr_field,
                   EnergyLevelMap& nlte_field,
                   // WS Input:
                   const Vector& p_grid,
                   const Vector& lat_grid,
                   const Vector& lon_grid,
                   const GriddedField3& t_field_raw,
                   const GriddedField3& z_field_raw,
                   const ArrayOfGriddedField3& vmr_field_raw,
                   const ArrayOfGriddedField3& nlte_field_raw,
                   const ArrayOfQuantumIdentifier& nlte_level_identifiers,
                   const Vector& nlte_vibrational_energies,
                   const Index& atmosphere_dim,
                   // WS Generic Input:
                   const Index& interp_order,
                   const Index& vmr_zeropadding,
                   const Index& vmr_nonegative,
                   const Index& nlte_when_negative,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void AtmFieldsCalcExpand1D(// WS Output:
                           Tensor3& t_field,
                           Tensor3& z_field,
                           Tensor4& vmr_field,
                           EnergyLevelMap& nlte_field,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           const GriddedField3& t_field_raw,
                           const GriddedField3& z_field_raw,
                           const ArrayOfGriddedField3& vmr_field_raw,
                           const ArrayOfGriddedField3& nlte_field_raw,
                           const ArrayOfQuantumIdentifier& nlte_level_identifiers,
                           const Vector& nlte_vibrational_energies,
                           const Index& atmosphere_dim,
                           // WS Generic Input:
                           const Index& interp_order,
                           const Index& vmr_zeropadding,
                           const Index& vmr_nonegative,
                           const Index& nlte_when_negative,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void AtmFieldsExpand1D(// WS Output:
                       Tensor3& t_field,
                       Tensor3& z_field,
                       Tensor4& vmr_field,
                       // WS Input:
                       const Vector& p_grid,
                       const Vector& lat_grid,
                       const Vector& lon_grid,
                       const Index& atmosphere_dim,
                       // WS Generic Input:
                       const Index& chk_vmr_nan,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void AtmFieldsExtract1D(// WS Output:
                        Index& atmosphere_dim,
                        Vector& lat_grid,
                        Vector& lon_grid,
                        Tensor3& t_field,
                        Tensor3& z_field,
                        Tensor4& vmr_field,
                        // WS Generic Input:
                        const Index& ilat,
                        const Index& ilon,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void AtmFieldsRefinePgrid(// WS Output:
                          Vector& p_grid,
                          Tensor3& t_field,
                          Tensor3& z_field,
                          Tensor4& vmr_field,
                          Index& atmfields_checked,
                          Index& atmgeom_checked,
                          Index& cloudbox_checked,
                          // WS Input:
                          const Vector& lat_grid,
                          const Vector& lon_grid,
                          const Index& atmosphere_dim,
                          // WS Generic Input:
                          const Numeric& p_step,
                          const Index& interp_order,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void AtmFieldsAndParticleBulkPropFieldFromCompact(// WS Output:
                                                  Vector& p_grid,
                                                  Vector& lat_grid,
                                                  Vector& lon_grid,
                                                  Tensor3& t_field,
                                                  Tensor3& z_field,
                                                  Tensor4& vmr_field,
                                                  Tensor4& particle_bulkprop_field,
                                                  ArrayOfString& particle_bulkprop_names,
                                                  // WS Input:
                                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                                  const GriddedField4& atm_fields_compact,
                                                  const Index& atmosphere_dim,
                                                  // WS Generic Input:
                                                  const String& delim,
                                                  const Numeric& p_min,
                                                  const Index& check_gridnames,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);
 
 
void atmfields_checkedCalc(// WS Output:
                           Index& atmfields_checked,
                           // WS Input:
                           const Index& atmosphere_dim,
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           const ArrayOfArrayOfSpeciesTag& abs_species,
                           const Tensor3& t_field,
                           const Tensor4& vmr_field,
                           const Tensor3& wind_u_field,
                           const Tensor3& wind_v_field,
                           const Tensor3& wind_w_field,
                           const Tensor3& mag_u_field,
                           const Tensor3& mag_v_field,
                           const Tensor3& mag_w_field,
                           const Index& abs_f_interp_order,
                           // WS Generic Input:
                           const Index& negative_vmr_ok,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void atmgeom_checkedCalc(// WS Output:
                         Index& atmgeom_checked,
                         // WS Input:
                         const Index& atmosphere_dim,
                         const Vector& p_grid,
                         const Vector& lat_grid,
                         const Vector& lon_grid,
                         const Tensor3& z_field,
                         const Vector& refellipsoid,
                         const Matrix& z_surface,
                         const Vector& lat_true,
                         const Vector& lon_true,
                         // WS Generic Input:
                         const Numeric& max500hpa_gradient,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void AtmosphereSet1D(// WS Output:
                     Index& atmosphere_dim,
                     Vector& lat_grid,
                     Vector& lon_grid,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void AtmosphereSet2D(// WS Output:
                     Index& atmosphere_dim,
                     Vector& lon_grid,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void AtmosphereSet3D(// WS Output:
                     Index& atmosphere_dim,
                     Vector& lat_true,
                     Vector& lon_true,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void AtmRawRead(// WS Output:
                GriddedField3& t_field_raw,
                GriddedField3& z_field_raw,
                ArrayOfGriddedField3& vmr_field_raw,
                ArrayOfGriddedField3& nlte_field_raw,
                ArrayOfQuantumIdentifier& nlte_level_identifiers,
                Vector& nlte_vibrational_energies,
                // WS Input:
                const ArrayOfArrayOfSpeciesTag& abs_species,
                // WS Generic Input:
                const String& basename,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void AtmWithNLTERawRead(// WS Output:
                        GriddedField3& t_field_raw,
                        GriddedField3& z_field_raw,
                        ArrayOfGriddedField3& vmr_field_raw,
                        ArrayOfGriddedField3& nlte_field_raw,
                        ArrayOfQuantumIdentifier& nlte_level_identifiers,
                        Vector& nlte_vibrational_energies,
                        // WS Input:
                        const ArrayOfArrayOfSpeciesTag& abs_species,
                        // WS Generic Input:
                        const String& basename,
                        const Index& expect_vibrational_energies,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void atm_fields_compactAddConstant(// WS Output:
                                   GriddedField4& atm_fields_compact,
                                   // WS Generic Input:
                                   const String& name,
                                   const Numeric& value,
                                   const Index& prepend,
                                   const ArrayOfString& condensibles,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void atm_fields_compactAddSpecies(// WS Output:
                                  GriddedField4& atm_fields_compact,
                                  // WS Generic Input:
                                  const String& name,
                                  const GriddedField3& value,
                                  const Index& prepend,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void atm_fields_compactCleanup(// WS Output:
                               GriddedField4& atm_fields_compact,
                               // WS Generic Input:
                               const Numeric& threshold,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void atm_fields_compactCreateFromField(// WS Output:
                                       GriddedField4& atm_fields_compact,
                                       // WS Generic Input:
                                       const String& name,
                                       const GriddedField3& field,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void atm_fields_compactFromMatrix(// WS Output:
                                  GriddedField4& atm_fields_compact,
                                  // WS Input:
                                  const Index& atmosphere_dim,
                                  // WS Generic Input:
                                  const Matrix& gin1,
                                  const ArrayOfString& field_names,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void backend_channel_responseFlat(// WS Output:
                                  ArrayOfGriddedField1& backend_channel_response,
                                  // WS Generic Input:
                                  const Numeric& resolution,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void backend_channel_responseGaussian(// WS Output:
                                      ArrayOfGriddedField1& backend_channel_response,
                                      // WS Generic Input:
                                      const Vector& fwhm,
                                      const Vector& xwidth_si,
                                      const Vector& dx_si,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void batch_atm_fields_compactAddConstant(// WS Output:
                                         ArrayOfGriddedField4& batch_atm_fields_compact,
                                         // WS Generic Input:
                                         const String& name,
                                         const Numeric& value,
                                         const Index& prepend,
                                         const ArrayOfString& condensibles,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void batch_atm_fields_compactAddSpecies(// WS Output:
                                        ArrayOfGriddedField4& batch_atm_fields_compact,
                                        // WS Generic Input:
                                        const String& name,
                                        const GriddedField3& value,
                                        const Index& prepend,
                                        // Verbosity object:
                                        const Verbosity& verbosity);
 
 
void batch_atm_fields_compactCleanup(// WS Output:
                                     ArrayOfGriddedField4& batch_atm_fields_compact,
                                     // WS Generic Input:
                                     const Numeric& threshold,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void batch_atm_fields_compactFromArrayOfMatrix(// WS Output:
                                               ArrayOfGriddedField4& batch_atm_fields_compact,
                                               // WS Input:
                                               const Index& atmosphere_dim,
                                               // WS Generic Input:
                                               const ArrayOfMatrix& atmospheres_fields,
                                               const ArrayOfString& field_names,
                                               // Verbosity object:
                                               const Verbosity& verbosity);
 
 
void CIAInfo(// WS Generic Input:
             const String& catalogpath,
             const ArrayOfString& cia_tags,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void CIARecordReadFromFile(// WS Generic Output:
                           CIARecord& cia_record,
                           // WS Generic Input:
                           const String& species_tag,
                           const String& filename,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void cloudboxOff(// WS Output:
                 Index& cloudbox_on,
                 Index& ppath_inside_cloudbox_do,
                 ArrayOfIndex& cloudbox_limits,
                 Agenda& iy_cloudbox_agenda,
                 Tensor4& pnd_field,
                 ArrayOfTensor4& dpnd_field_dx,
                 ArrayOfString& scat_species,
                 ArrayOfArrayOfSingleScatteringData& scat_data,
                 ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                 Index& scat_data_checked,
                 Matrix& particle_masses,
                 // WS Input:
                 const ArrayOfRetrievalQuantity& jacobian_quantities,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void cloudboxSetAutomatically(// WS Output:
                              Index& cloudbox_on,
                              ArrayOfIndex& cloudbox_limits,
                              // WS Input:
                              const Index& atmosphere_dim,
                              const Vector& p_grid,
                              const Vector& lat_grid,
                              const Vector& lon_grid,
                              // WS Generic Input:
                              const Tensor4& particle_field,
                              const Numeric& cloudbox_margin,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void cloudboxSetFullAtm(// WS Output:
                        Index& cloudbox_on,
                        ArrayOfIndex& cloudbox_limits,
                        // WS Input:
                        const Index& atmosphere_dim,
                        const Vector& p_grid,
                        const Vector& lat_grid,
                        const Vector& lon_grid,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void cloudboxSetManually(// WS Output:
                         Index& cloudbox_on,
                         ArrayOfIndex& cloudbox_limits,
                         // WS Input:
                         const Index& atmosphere_dim,
                         const Vector& p_grid,
                         const Vector& lat_grid,
                         const Vector& lon_grid,
                         // WS Generic Input:
                         const Numeric& p1,
                         const Numeric& p2,
                         const Numeric& lat1,
                         const Numeric& lat2,
                         const Numeric& lon1,
                         const Numeric& lon2,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void cloudboxSetManuallyAltitude(// WS Output:
                                 Index& cloudbox_on,
                                 ArrayOfIndex& cloudbox_limits,
                                 // WS Input:
                                 const Index& atmosphere_dim,
                                 const Tensor3& z_field,
                                 const Vector& lat_grid,
                                 const Vector& lon_grid,
                                 // WS Generic Input:
                                 const Numeric& z1,
                                 const Numeric& z2,
                                 const Numeric& lat1,
                                 const Numeric& lat2,
                                 const Numeric& lon1,
                                 const Numeric& lon2,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void cloudbox_checkedCalc(// WS Output:
                          Index& cloudbox_checked,
                          // WS Input:
                          const Index& atmfields_checked,
                          const Index& atmosphere_dim,
                          const Vector& p_grid,
                          const Vector& lat_grid,
                          const Vector& lon_grid,
                          const Tensor3& z_field,
                          const Matrix& z_surface,
                          const Tensor3& wind_u_field,
                          const Tensor3& wind_v_field,
                          const Tensor3& wind_w_field,
                          const Index& cloudbox_on,
                          const ArrayOfIndex& cloudbox_limits,
                          const Tensor4& pnd_field,
                          const ArrayOfTensor4& dpnd_field_dx,
                          const ArrayOfRetrievalQuantity& jacobian_quantities,
                          const ArrayOfArrayOfSingleScatteringData& scat_data,
                          const ArrayOfString& scat_species,
                          const Matrix& particle_masses,
                          const ArrayOfArrayOfSpeciesTag& abs_species,
                          // WS Generic Input:
                          const Index& negative_pnd_ok,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void cloudbox_field_monoIterate(// Workspace reference:
                                Workspace& ws,
                                // WS Output:
                                Tensor6& cloudbox_field_mono,
                                // WS Input:
                                const Agenda& doit_scat_field_agenda,
                                const Agenda& doit_rte_agenda,
                                const Agenda& doit_conv_test_agenda,
                                // WS Generic Input:
                                const Index& accelerated,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void cloudbox_fieldCrop(// WS Output:
                        Tensor7& cloudbox_field,
                        ArrayOfIndex& cloudbox_limits,
                        // WS Input:
                        const Index& atmosphere_dim,
                        const Index& cloudbox_on,
                        // WS Generic Input:
                        const Index& new_limit0,
                        const Index& new_limit1,
                        const Index& new_limit2,
                        const Index& new_limit3,
                        const Index& new_limit4,
                        const Index& new_limit5,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void cloudbox_fieldSetFromPrecalc(// WS Output:
                                  Tensor7& cloudbox_field,
                                  // WS Input:
                                  const Vector& za_grid,
                                  const Vector& f_grid,
                                  const Index& atmosphere_dim,
                                  const Index& stokes_dim,
                                  const ArrayOfIndex& cloudbox_limits,
                                  const Index& doit_is_initialized,
                                  // WS Generic Input:
                                  const Tensor7& cloudbox_field_precalc,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void cloudbox_fieldSetClearsky(// WS Output:
                               Tensor7& cloudbox_field,
                               // WS Input:
                               const Vector& p_grid,
                               const Vector& lat_grid,
                               const Vector& lon_grid,
                               const ArrayOfIndex& cloudbox_limits,
                               const Index& atmosphere_dim,
                               const Index& cloudbox_on,
                               const Index& doit_is_initialized,
                               // WS Generic Input:
                               const Index& all_frequencies,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void cloudbox_field_monoSetConst(// WS Output:
                                 Tensor6& cloudbox_field_mono,
                                 // WS Input:
                                 const Vector& p_grid,
                                 const Vector& lat_grid,
                                 const Vector& lon_grid,
                                 const ArrayOfIndex& cloudbox_limits,
                                 const Index& atmosphere_dim,
                                 const Index& stokes_dim,
                                 // WS Generic Input:
                                 const Vector& value,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void cloudbox_fieldSetConst(// WS Output:
                            Tensor7& cloudbox_field,
                            // WS Input:
                            const Vector& p_grid,
                            const Vector& lat_grid,
                            const Vector& lon_grid,
                            const ArrayOfIndex& cloudbox_limits,
                            const Index& atmosphere_dim,
                            const Index& stokes_dim,
                            // WS Generic Input:
                            const Vector& value,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void cloudbox_fieldSetConstPerFreq(// WS Output:
                                   Tensor7& cloudbox_field,
                                   // WS Input:
                                   const Vector& p_grid,
                                   const Vector& lat_grid,
                                   const Vector& lon_grid,
                                   const ArrayOfIndex& cloudbox_limits,
                                   const Index& atmosphere_dim,
                                   const Index& stokes_dim,
                                   // WS Generic Input:
                                   const Matrix& value,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void cloudbox_fieldUpdate1D(// Workspace reference:
                            Workspace& ws,
                            // WS Output:
                            Tensor6& cloudbox_field_mono,
                            // WS Input:
                            const Tensor6& doit_scat_field,
                            const ArrayOfIndex& cloudbox_limits,
                            const Agenda& propmat_clearsky_agenda,
                            const Tensor4& vmr_field,
                            const Agenda& spt_calc_agenda,
                            const Vector& za_grid,
                            const Tensor4& pnd_field,
                            const Agenda& ppath_step_agenda,
                            const Numeric& ppath_lmax,
                            const Numeric& ppath_lraytrace,
                            const Vector& p_grid,
                            const Tensor3& z_field,
                            const Vector& refellipsoid,
                            const Tensor3& t_field,
                            const Vector& f_grid,
                            const Index& f_index,
                            const Agenda& surface_rtprop_agenda,
                            const Index& doit_za_interp,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void cloudbox_fieldUpdateSeq1D(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               Tensor6& cloudbox_field_mono,
                               Tensor6& doit_scat_field,
                               // WS Input:
                               const ArrayOfIndex& cloudbox_limits,
                               const Agenda& propmat_clearsky_agenda,
                               const Tensor4& vmr_field,
                               const Agenda& spt_calc_agenda,
                               const Vector& za_grid,
                               const Vector& aa_grid,
                               const Tensor4& pnd_field,
                               const Agenda& ppath_step_agenda,
                               const Numeric& ppath_lmax,
                               const Numeric& ppath_lraytrace,
                               const Vector& p_grid,
                               const Tensor3& z_field,
                               const Vector& refellipsoid,
                               const Tensor3& t_field,
                               const Vector& f_grid,
                               const Index& f_index,
                               const Agenda& surface_rtprop_agenda,
                               const Index& doit_za_interp,
                               // WS Generic Input:
                               const Index& normalize,
                               const Numeric& norm_error_threshold,
                               const Index& norm_debug,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void cloudbox_fieldUpdateSeq1DPP(// Workspace reference:
                                 Workspace& ws,
                                 // WS Output:
                                 Tensor6& cloudbox_field_mono,
                                 Index& za_index,
                                 // WS Input:
                                 const Tensor6& doit_scat_field,
                                 const ArrayOfIndex& cloudbox_limits,
                                 const Agenda& propmat_clearsky_agenda,
                                 const Tensor4& vmr_field,
                                 const Agenda& spt_calc_agenda,
                                 const Vector& za_grid,
                                 const Tensor4& pnd_field,
                                 const Vector& p_grid,
                                 const Tensor3& z_field,
                                 const Tensor3& t_field,
                                 const Vector& f_grid,
                                 const Index& f_index,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void cloudbox_fieldUpdateSeq3D(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               Tensor6& cloudbox_field_mono,
                               // WS Input:
                               const Tensor6& doit_scat_field,
                               const ArrayOfIndex& cloudbox_limits,
                               const Agenda& propmat_clearsky_agenda,
                               const Tensor4& vmr_field,
                               const Agenda& spt_calc_agenda,
                               const Vector& za_grid,
                               const Vector& aa_grid,
                               const Tensor4& pnd_field,
                               const Agenda& ppath_step_agenda,
                               const Numeric& ppath_lmax,
                               const Numeric& ppath_lraytrace,
                               const Vector& p_grid,
                               const Vector& lat_grid,
                               const Vector& lon_grid,
                               const Tensor3& z_field,
                               const Vector& refellipsoid,
                               const Tensor3& t_field,
                               const Vector& f_grid,
                               const Index& f_index,
                               const Index& doit_za_interp,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void cloudbox_field_monoOptimizeReverse(// WS Output:
                                        Tensor6& cloudbox_field_mono,
                                        // WS Input:
                                        const Vector& p_grid_orig,
                                        const Vector& p_grid,
                                        const ArrayOfIndex& cloudbox_limits,
                                        // Verbosity object:
                                        const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Numeric& var1,
             const Numeric& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Vector& var1,
             const Vector& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Matrix& var1,
             const Matrix& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Tensor3& var1,
             const Tensor3& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Tensor4& var1,
             const Tensor4& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Tensor5& var1,
             const Tensor5& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Tensor7& var1,
             const Tensor7& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const ArrayOfVector& var1,
             const ArrayOfVector& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const ArrayOfMatrix& var1,
             const ArrayOfMatrix& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const ArrayOfTensor7& var1,
             const ArrayOfTensor7& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const GriddedField3& var1,
             const GriddedField3& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const Sparse& var1,
             const Sparse& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Compare(// WS Generic Input:
             const SingleScatteringData& var1,
             const SingleScatteringData& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Numeric& var1,
                     const Numeric& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Vector& var1,
                     const Vector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Matrix& var1,
                     const Matrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Tensor3& var1,
                     const Tensor3& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Tensor4& var1,
                     const Tensor4& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Tensor5& var1,
                     const Tensor5& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Tensor6& var1,
                     const Tensor6& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const Tensor7& var1,
                     const Tensor7& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfVector& var1,
                     const ArrayOfVector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfMatrix& var1,
                     const ArrayOfMatrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfTensor3& var1,
                     const ArrayOfTensor3& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfTensor4& var1,
                     const ArrayOfTensor4& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfTensor6& var1,
                     const ArrayOfTensor6& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfTensor7& var1,
                     const ArrayOfTensor7& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfVector& var1,
                     const ArrayOfArrayOfVector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfMatrix& var1,
                     const ArrayOfArrayOfMatrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfTensor3& var1,
                     const ArrayOfArrayOfTensor3& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfTensor6& var1,
                     const ArrayOfArrayOfTensor6& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfPropagationMatrix& var1,
                     const ArrayOfPropagationMatrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfPropagationMatrix& var1,
                     const ArrayOfArrayOfPropagationMatrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfStokesVector& var1,
                     const ArrayOfStokesVector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfStokesVector& var1,
                     const ArrayOfArrayOfStokesVector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void CompareRelative(// WS Generic Input:
                     const EnergyLevelMap& var1,
                     const EnergyLevelMap& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void 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 complex_refr_indexConstant(// WS Output:
                                GriddedField3& complex_refr_index,
                                // WS Generic Input:
                                const Numeric& refr_index_real,
                                const Numeric& refr_index_imag,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void complex_refr_indexIceMatzler06(// WS Output:
                                    GriddedField3& complex_refr_index,
                                    // WS Generic Input:
                                    const Vector& data_f_grid,
                                    const Vector& data_T_grid,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void complex_refr_indexIceWarren84(// WS Output:
                                   GriddedField3& complex_refr_index,
                                   // WS Generic Input:
                                   const Vector& data_f_grid,
                                   const Vector& data_T_grid,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void complex_refr_indexWaterLiebe93(// WS Output:
                                    GriddedField3& complex_refr_index,
                                    // WS Generic Input:
                                    const Vector& data_f_grid,
                                    const Vector& data_T_grid,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void covmat_sxExtractSqrtDiagonal(// WS Generic Output:
                                  Vector& x_norm,
                                  // WS Input:
                                  const CovarianceMatrix& covmat_sx,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void diameter_maxFromDiameter_volume_equ(// WS Generic Output:
                                         Numeric& diameter_max,
                                         Numeric& diameter_area_equ,
                                         // WS Generic Input:
                                         const String& shape,
                                         const Numeric& diameter_volume_equ,
                                         const Numeric& aspect_ratio,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void diameter_volume_equFromDiameter_max(// WS Generic Output:
                                         Numeric& diameter_volume_equ,
                                         Numeric& volume,
                                         // WS Generic Input:
                                         const String& shape,
                                         const Numeric& diameter_max,
                                         const Numeric& aspect_ratio,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void DiagonalMatrix(// WS Generic Output:
                    Matrix& out,
                    // WS Generic Input:
                    const Vector& v,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void DiagonalMatrix(// WS Generic Output:
                    Sparse& out,
                    // WS Generic Input:
                    const Vector& v,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void DiffZaAa(// WS Generic Output:
              Matrix& dlos,
              // WS Generic Input:
              const Vector& ref_los,
              const Matrix& other_los,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void DisortCalc(// Workspace reference:
                Workspace& ws,
                // WS Output:
                Tensor7& cloudbox_field,
                // WS Input:
                const Index& atmfields_checked,
                const Index& atmgeom_checked,
                const Index& scat_data_checked,
                const Index& cloudbox_checked,
                const Index& cloudbox_on,
                const ArrayOfIndex& cloudbox_limits,
                const Agenda& propmat_clearsky_agenda,
                const Index& atmosphere_dim,
                const Tensor4& pnd_field,
                const Tensor3& t_field,
                const Tensor3& z_field,
                const Tensor4& vmr_field,
                const Vector& p_grid,
                const ArrayOfArrayOfSingleScatteringData& scat_data,
                const Vector& f_grid,
                const Vector& za_grid,
                const Index& stokes_dim,
                const Matrix& z_surface,
                const Numeric& surface_skin_t,
                const Vector& surface_scalar_reflectivity,
                // WS Generic Input:
                const Index& nstreams,
                const Index& Npfct,
                const Index& quiet,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void DisortCalcWithARTSSurface(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               Tensor7& cloudbox_field,
                               // WS Input:
                               const Index& atmfields_checked,
                               const Index& atmgeom_checked,
                               const Index& scat_data_checked,
                               const Index& cloudbox_checked,
                               const Index& cloudbox_on,
                               const ArrayOfIndex& cloudbox_limits,
                               const Agenda& propmat_clearsky_agenda,
                               const Agenda& surface_rtprop_agenda,
                               const Index& atmosphere_dim,
                               const Tensor4& pnd_field,
                               const Tensor3& t_field,
                               const Tensor3& z_field,
                               const Tensor4& vmr_field,
                               const Vector& p_grid,
                               const Matrix& z_surface,
                               const ArrayOfArrayOfSingleScatteringData& scat_data,
                               const Vector& f_grid,
                               const Vector& za_grid,
                               const Index& stokes_dim,
                               // WS Generic Input:
                               const Index& nstreams,
                               const Index& Npfct,
                               const Index& quiet,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void DisortCalcClearsky(// Workspace reference:
                        Workspace& ws,
                        // WS Output:
                        Tensor7& spectral_radiance_field,
                        // WS Input:
                        const Index& atmfields_checked,
                        const Index& atmgeom_checked,
                        const Agenda& propmat_clearsky_agenda,
                        const Index& atmosphere_dim,
                        const Tensor3& t_field,
                        const Tensor3& z_field,
                        const Tensor4& vmr_field,
                        const Vector& p_grid,
                        const Vector& f_grid,
                        const Vector& za_grid,
                        const Index& stokes_dim,
                        const Matrix& z_surface,
                        const Numeric& surface_skin_t,
                        const Vector& surface_scalar_reflectivity,
                        // WS Generic Input:
                        const Index& nstreams,
                        const Index& quiet,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void DOBatchCalc(// Workspace reference:
                 Workspace& ws,
                 // WS Output:
                 ArrayOfTensor7& dobatch_cloudbox_field,
                 ArrayOfTensor5& dobatch_radiance_field,
                 ArrayOfTensor4& dobatch_irradiance_field,
                 ArrayOfTensor5& dobatch_spectral_irradiance_field,
                 // WS Input:
                 const Index& ybatch_start,
                 const Index& ybatch_n,
                 const Agenda& dobatch_calc_agenda,
                 // WS Generic Input:
                 const Index& robust,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void DOAngularGridsSet(// WS Output:
                       Index& doit_za_grid_size,
                       Vector& aa_grid,
                       Vector& za_grid,
                       // WS Generic Input:
                       const Index& N_za_grid,
                       const Index& N_aa_grid,
                       const String& za_grid_opt_file,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void DoitCalc(// Workspace reference:
              Workspace& ws,
              // WS Output:
              Tensor7& cloudbox_field,
              // WS Input:
              const Index& atmfields_checked,
              const Index& atmgeom_checked,
              const Index& cloudbox_checked,
              const Index& scat_data_checked,
              const Index& cloudbox_on,
              const Vector& f_grid,
              const Agenda& doit_mono_agenda,
              const Index& doit_is_initialized,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void DoitGetIncoming(// Workspace reference:
                     Workspace& ws,
                     // WS Output:
                     Tensor7& cloudbox_field,
                     // WS Input:
                     const Index& atmfields_checked,
                     const Index& atmgeom_checked,
                     const Index& cloudbox_checked,
                     const Index& doit_is_initialized,
                     const Agenda& iy_main_agenda,
                     const Index& atmosphere_dim,
                     const Vector& lat_grid,
                     const Vector& lon_grid,
                     const Tensor3& z_field,
                     const EnergyLevelMap& nlte_field,
                     const Index& cloudbox_on,
                     const ArrayOfIndex& cloudbox_limits,
                     const Vector& f_grid,
                     const Index& stokes_dim,
                     const Vector& za_grid,
                     const Vector& aa_grid,
                     // WS Generic Input:
                     const Index& rigorous,
                     const Numeric& maxratio,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void DoitGetIncoming1DAtm(// Workspace reference:
                          Workspace& ws,
                          // WS Output:
                          Tensor7& cloudbox_field,
                          Index& cloudbox_on,
                          // WS Input:
                          const Index& atmfields_checked,
                          const Index& atmgeom_checked,
                          const Index& cloudbox_checked,
                          const Index& doit_is_initialized,
                          const Agenda& iy_main_agenda,
                          const Index& atmosphere_dim,
                          const Vector& lat_grid,
                          const Vector& lon_grid,
                          const Tensor3& z_field,
                          const EnergyLevelMap& nlte_field,
                          const ArrayOfIndex& cloudbox_limits,
                          const Vector& f_grid,
                          const Index& stokes_dim,
                          const Vector& za_grid,
                          const Vector& aa_grid,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void DoitInit(// WS Output:
              Tensor6& doit_scat_field,
              Tensor7& cloudbox_field,
              Index& doit_is_initialized,
              // WS Input:
              const Index& stokes_dim,
              const Index& atmosphere_dim,
              const Vector& f_grid,
              const Vector& za_grid,
              const Vector& aa_grid,
              const Index& doit_za_grid_size,
              const Index& cloudbox_on,
              const ArrayOfIndex& cloudbox_limits,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void DoitScatteringDataPrepare(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               ArrayOfTensor7& pha_mat_sptDOITOpt,
                               ArrayOfArrayOfSingleScatteringData& scat_data_mono,
                               Tensor7& pha_mat_doit,
                               Vector& aa_grid,
                               // WS Input:
                               const Index& doit_za_grid_size,
                               const ArrayOfArrayOfSingleScatteringData& scat_data,
                               const Index& scat_data_checked,
                               const Index& f_index,
                               const Index& atmosphere_dim,
                               const Index& stokes_dim,
                               const Tensor3& t_field,
                               const ArrayOfIndex& cloudbox_limits,
                               const Tensor4& pnd_field,
                               const Agenda& pha_mat_spt_agenda,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void DoitWriteIterationFields(// WS Input:
                              const Index& doit_iteration_counter,
                              const Tensor6& cloudbox_field_mono,
                              const Index& f_index,
                              // WS Generic Input:
                              const ArrayOfIndex& iterations,
                              const ArrayOfIndex& frequencies,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void doit_conv_flagAbs(// WS Output:
                       Index& doit_conv_flag,
                       Index& doit_iteration_counter,
                       Tensor6& cloudbox_field_mono,
                       // WS Input:
                       const Tensor6& cloudbox_field_mono_old,
                       // WS Generic Input:
                       const Vector& epsilon,
                       const Index& max_iterations,
                       const Index& nonconv_return_nan,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void doit_conv_flagAbsBT(// WS Output:
                         Index& doit_conv_flag,
                         Index& doit_iteration_counter,
                         Tensor6& cloudbox_field_mono,
                         // WS Input:
                         const Tensor6& cloudbox_field_mono_old,
                         const Vector& f_grid,
                         const Index& f_index,
                         // WS Generic Input:
                         const Vector& epsilon,
                         const Index& max_iterations,
                         const Index& nonconv_return_nan,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void doit_conv_flagLsq(// WS Output:
                       Index& doit_conv_flag,
                       Index& doit_iteration_counter,
                       Tensor6& cloudbox_field_mono,
                       // WS Input:
                       const Tensor6& cloudbox_field_mono_old,
                       const Vector& f_grid,
                       const Index& f_index,
                       // WS Generic Input:
                       const Vector& epsilon,
                       const Index& max_iterations,
                       const Index& nonconv_return_nan,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void OptimizeDoitPressureGrid(// Workspace reference:
                              Workspace& ws,
                              // WS Output:
                              Vector& p_grid,
                              Tensor4& pnd_field,
                              Tensor3& t_field,
                              ArrayOfArrayOfSingleScatteringData& scat_data_mono,
                              Tensor3& z_field,
                              ArrayOfIndex& cloudbox_limits,
                              Tensor6& cloudbox_field_mono,
                              Tensor7& pha_mat_doit,
                              Tensor4& vmr_field,
                              Vector& p_grid_orig,
                              // WS Input:
                              const Vector& f_grid,
                              const Index& f_index,
                              const Agenda& propmat_clearsky_agenda,
                              // WS Generic Input:
                              const Numeric& tau_scat_max,
                              const Numeric& sgl_alb_max,
                              const Index& cloudbox_size_max,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void doit_scat_fieldCalc(// Workspace reference:
                         Workspace& ws,
                         // WS Output:
                         Tensor6& doit_scat_field,
                         // WS Input:
                         const Agenda& pha_mat_spt_agenda,
                         const Tensor6& cloudbox_field_mono,
                         const Tensor4& pnd_field,
                         const Tensor3& t_field,
                         const Index& atmosphere_dim,
                         const ArrayOfIndex& cloudbox_limits,
                         const Vector& za_grid,
                         const Vector& aa_grid,
                         const Index& doit_za_grid_size,
                         const Tensor7& pha_mat_doit,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void doit_scat_fieldCalcLimb(// Workspace reference:
                             Workspace& ws,
                             // WS Output:
                             Tensor6& doit_scat_field,
                             // WS Input:
                             const Agenda& pha_mat_spt_agenda,
                             const Tensor6& cloudbox_field_mono,
                             const Tensor4& pnd_field,
                             const Tensor3& t_field,
                             const Index& atmosphere_dim,
                             const ArrayOfIndex& cloudbox_limits,
                             const Vector& za_grid,
                             const Vector& aa_grid,
                             const Index& doit_za_grid_size,
                             const Index& doit_za_interp,
                             const Tensor7& pha_mat_doit,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void doit_za_grid_optCalc(// WS Output:
                          Vector& doit_za_grid_opt,
                          // WS Input:
                          const Tensor6& cloudbox_field_mono,
                          const Vector& za_grid,
                          const Index& doit_za_interp,
                          // WS Generic Input:
                          const Numeric& acc,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void doit_za_interpSet(// WS Output:
                       Index& doit_za_interp,
                       // WS Input:
                       const Index& atmosphere_dim,
                       // WS Generic Input:
                       const String& interp_method,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void Duration(// WS Generic Output:
              Numeric& duration,
              // WS Generic Input:
              const Time& start,
              const Time& end,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void ecs_dataAddMakarov2020(// WS Output:
                            MapOfErrorCorrectedSuddenData& ecs_data,
                            // WS Input:
                            const SpeciesIsotopologueRatios& isotopologue_ratios,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void ecs_dataAddRodrigues1997(// WS Output:
                              MapOfErrorCorrectedSuddenData& ecs_data,
                              // WS Input:
                              const SpeciesIsotopologueRatios& isotopologue_ratios,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void ecs_dataAddTran2011(// WS Output:
                         MapOfErrorCorrectedSuddenData& ecs_data,
                         // WS Input:
                         const SpeciesIsotopologueRatios& isotopologue_ratios,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ecs_dataInit(// WS Output:
                  MapOfErrorCorrectedSuddenData& ecs_data,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void ecs_dataSetMeanAir(// WS Output:
                        MapOfErrorCorrectedSuddenData& ecs_data,
                        // WS Generic Input:
                        const Vector& vmrs,
                        const ArrayOfSpeciesTag& specs,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void ecs_dataSetSpeciesData(// WS Output:
                            MapOfErrorCorrectedSuddenData& ecs_data,
                            // WS Input:
                            const SpeciesIsotopologueRatios& isotopologue_ratios,
                            // WS Generic Input:
                            const QuantumIdentifier& qid,
                            const String& species,
                            const String& scaling_type,
                            const Vector& scaling,
                            const String& beta_type,
                            const Vector& beta,
                            const String& lambda_type,
                            const Vector& lambda,
                            const String& collisional_distance_type,
                            const Vector& collisional_distance,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void EnergyLevelMapSet(// WS Generic Output:
                       EnergyLevelMap& x,
                       // WS Generic Input:
                       const EnergyLevelMap& y,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void Error(// WS Generic Input:
           const String& msg,
           // Verbosity object:
           const Verbosity& verbosity);
 
 
void Exit(// Verbosity object:
          const Verbosity& verbosity);
 
 
void ExtractFromMetaSingleScatSpecies(// WS Generic Output:
                                      Vector& meta_param,
                                      // WS Input:
                                      const ArrayOfArrayOfScatteringMetaData& scat_meta,
                                      // WS Generic Input:
                                      const String& meta_name,
                                      const Index& scat_species_index,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void ext_matAddGas(// WS Output:
                   PropagationMatrix& ext_mat,
                   // WS Input:
                   const PropagationMatrix& propmat_clearsky,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void FastemStandAlone(// WS Generic Output:
                      Matrix& emissivity,
                      Matrix& reflectivity,
                      // WS Input:
                      const Vector& f_grid,
                      const Numeric& surface_skin_t,
                      // WS Generic Input:
                      const Numeric& za,
                      const Numeric& salinity,
                      const Numeric& wind_speed,
                      const Numeric& rel_aa,
                      const Vector& transmittance,
                      const Index& fastem_version,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void FieldFromGriddedField(// WS Generic Output:
                           Matrix& out,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           // WS Generic Input:
                           const GriddedField2& in,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void FieldFromGriddedField(// WS Generic Output:
                           Tensor3& out,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           // WS Generic Input:
                           const GriddedField3& in,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void FieldFromGriddedField(// WS Generic Output:
                           Tensor4& out,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           // WS Generic Input:
                           const GriddedField4& in,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void FieldFromGriddedField(// WS Generic Output:
                           Tensor4& out,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           // WS Generic Input:
                           const ArrayOfGriddedField3& in,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void FlagOff(// WS Generic Output:
             Index& flag,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void FlagOn(// WS Generic Output:
            Index& flag,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             ArrayOfTime& out,
             // WS Generic Input:
             const ArrayOfArrayOfTime& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             ArrayOfVector& out,
             // WS Generic Input:
             const ArrayOfArrayOfVector& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             Matrix& out,
             // WS Generic Input:
             const ArrayOfVector& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             Tensor3& out,
             // WS Generic Input:
             const ArrayOfMatrix& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             Tensor4& out,
             // WS Generic Input:
             const ArrayOfTensor3& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             Tensor5& out,
             // WS Generic Input:
             const ArrayOfTensor4& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             Tensor6& out,
             // WS Generic Input:
             const ArrayOfTensor5& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void Flatten(// WS Generic Output:
             Tensor7& out,
             // WS Generic Input:
             const ArrayOfTensor6& in,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void ForLoop(// Workspace reference:
             Workspace& ws,
             // WS Input:
             const Agenda& forloop_agenda,
             // WS Generic Input:
             const Index& start,
             const Index& stop,
             const Index& step,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void FrequencyFromWavelength(// WS Generic Output:
                             Numeric& frequency,
                             // WS Generic Input:
                             const Numeric& wavelength,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void FrequencyFromWavelength(// WS Generic Output:
                             Vector& frequency,
                             // WS Generic Input:
                             const Vector& wavelength,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void FrequencyFromCGSAngularWavenumber(// WS Generic Output:
                                       Numeric& frequency,
                                       // WS Generic Input:
                                       const Numeric& angular_wavenumber,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void FrequencyFromCGSAngularWavenumber(// WS Generic Output:
                                       Vector& frequency,
                                       // WS Generic Input:
                                       const Vector& angular_wavenumber,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void FrequencyFromCGSKayserWavenumber(// WS Generic Output:
                                      Numeric& frequency,
                                      // WS Generic Input:
                                      const Numeric& kayser_wavenumber,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void FrequencyFromCGSKayserWavenumber(// WS Generic Output:
                                      Vector& frequency,
                                      // WS Generic Input:
                                      const Vector& kayser_wavenumber,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void f_gridFromAbsorptionLines(// WS Output:
                               Vector& f_grid,
                               // WS Input:
                               const ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                               // WS Generic Input:
                               const Numeric& delta_f_low,
                               const Numeric& delta_f_upp,
                               const Index& num_freqs,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void f_gridFromGasAbsLookup(// WS Output:
                            Vector& f_grid,
                            // WS Input:
                            const GasAbsLookup& abs_lookup,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void f_gridFromSensorAMSU(// WS Output:
                          Vector& f_grid,
                          // WS Input:
                          const Vector& lo_multi,
                          const ArrayOfVector& f_backend_multi,
                          const ArrayOfArrayOfGriddedField1& backend_channel_response_multi,
                          // WS Generic Input:
                          const Numeric& spacing,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void f_gridFromSensorAMSUgeneric(// WS Output:
                                 Vector& f_grid,
                                 // WS Input:
                                 const ArrayOfVector& f_backend_multi,
                                 const ArrayOfArrayOfGriddedField1& backend_channel_response_multi,
                                 // WS Generic Input:
                                 const Numeric& spacing,
                                 const Vector& verbosityVect,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void f_gridFromSensorHIRS(// WS Output:
                          Vector& f_grid,
                          // WS Input:
                          const Vector& f_backend,
                          const ArrayOfGriddedField1& backend_channel_response,
                          // WS Generic Input:
                          const Numeric& spacing,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void f_gridMetMM(// WS Output:
                 Vector& f_grid,
                 Vector& f_backend,
                 ArrayOfArrayOfIndex& channel2fgrid_indexes,
                 ArrayOfVector& channel2fgrid_weights,
                 // WS Input:
                 const Matrix& met_mm_backend,
                 // WS Generic Input:
                 const Vector& freq_spacing,
                 const ArrayOfIndex& freq_number,
                 const Numeric& freq_merge_threshold,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void yMaskOutsideMedianRange(// WS Output:
                             Vector& y,
                             // WS Generic Input:
                             const Numeric& dx,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ybatchMaskOutsideMedianRange(// WS Output:
                                  ArrayOfVector& ybatch,
                                  // WS Generic Input:
                                  const Numeric& dx,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void yDoublingMeanFocus(// WS Output:
                        Vector& f_grid,
                        Vector& y,
                        // WS Generic Input:
                        const Numeric& f0,
                        const Numeric& df,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void ybatchDoublingMeanFocus(// WS Output:
                             Vector& f_grid,
                             ArrayOfVector& ybatch,
                             // WS Generic Input:
                             const Numeric& f0,
                             const Numeric& df,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void g0Earth(// WS Output:
             Numeric& g0,
             // WS Input:
             const Numeric& lat,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void g0Io(// WS Output:
          Numeric& g0,
          // Verbosity object:
          const Verbosity& verbosity);
 
 
void g0Jupiter(// WS Output:
               Numeric& g0,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void g0Mars(// WS Output:
            Numeric& g0,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void g0Venus(// WS Output:
             Numeric& g0,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void geo_posEndOfPpath(// WS Output:
                       Vector& geo_pos,
                       // WS Input:
                       const Ppath& ppath,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void geo_posLowestAltitudeOfPpath(// WS Output:
                                  Vector& geo_pos,
                                  // WS Input:
                                  const Ppath& ppath,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void geo_posWherePpathPassesZref(// WS Output:
                                 Vector& geo_pos,
                                 // WS Input:
                                 const Ppath& ppath,
                                 // WS Generic Input:
                                 const Numeric& z_ref,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void GetEnvironmentVariable(// WS Generic Output:
                            String& out,
                            // WS Generic Input:
                            const String& in,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void GetEnvironmentVariable(// WS Generic Output:
                            Index& out,
                            // WS Generic Input:
                            const String& in,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void GetNumberOfThreads(// WS Generic Output:
                        Index& nthreads,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void GriddedFieldLatLonExpand(// WS Generic Output:
                              GriddedField2& out,
                              // WS Generic Input:
                              const GriddedField2& in,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldLatLonExpand(// WS Generic Output:
                              GriddedField3& out,
                              // WS Generic Input:
                              const GriddedField3& in,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldLatLonExpand(// WS Generic Output:
                              GriddedField4& out,
                              // WS Generic Input:
                              const GriddedField4& in,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldLatLonExpand(// WS Generic Output:
                              ArrayOfGriddedField3& out,
                              // WS Generic Input:
                              const ArrayOfGriddedField3& in,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldLatLonRegrid(// WS Generic Output:
                              GriddedField2& out,
                              // WS Input:
                              const Vector& lat_true,
                              const Vector& lon_true,
                              // WS Generic Input:
                              const GriddedField2& in,
                              const Index& interp_order,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldLatLonRegrid(// WS Generic Output:
                              GriddedField3& out,
                              // WS Input:
                              const Vector& lat_true,
                              const Vector& lon_true,
                              // WS Generic Input:
                              const GriddedField3& in,
                              const Index& interp_order,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldLatLonRegrid(// WS Generic Output:
                              GriddedField4& out,
                              // WS Input:
                              const Vector& lat_true,
                              const Vector& lon_true,
                              // WS Generic Input:
                              const GriddedField4& in,
                              const Index& interp_order,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldLatLonRegrid(// WS Generic Output:
                              ArrayOfGriddedField3& out,
                              // WS Input:
                              const Vector& lat_true,
                              const Vector& lon_true,
                              // WS Generic Input:
                              const ArrayOfGriddedField3& in,
                              const Index& interp_order,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void GriddedFieldPRegrid(// WS Generic Output:
                         GriddedField3& out,
                         // WS Input:
                         const Vector& p_grid,
                         // WS Generic Input:
                         const GriddedField3& in,
                         const Index& interp_order,
                         const Index& zeropadding,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedFieldPRegrid(// WS Generic Output:
                         GriddedField4& out,
                         // WS Input:
                         const Vector& p_grid,
                         // WS Generic Input:
                         const GriddedField4& in,
                         const Index& interp_order,
                         const Index& zeropadding,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedFieldPRegrid(// WS Generic Output:
                         ArrayOfGriddedField3& out,
                         // WS Input:
                         const Vector& p_grid,
                         // WS Generic Input:
                         const ArrayOfGriddedField3& in,
                         const Index& interp_order,
                         const Index& zeropadding,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedFieldZToPRegrid(// WS Generic Output:
                            GriddedField3& out,
                            // WS Input:
                            const Vector& p_grid,
                            const Vector& lat_grid,
                            const Vector& lon_grid,
                            const Tensor3& z_field,
                            // WS Generic Input:
                            const GriddedField3& in,
                            const Index& interp_order,
                            const Index& zeropadding,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void heating_ratesFromIrradiance(// WS Output:
                                 Tensor3& heating_rates,
                                 // WS Input:
                                 const Vector& p_grid,
                                 const Tensor4& irradiance_field,
                                 const Tensor3& specific_heat_capacity,
                                 const Numeric& g0,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void INCLUDE(// Verbosity object:
             const Verbosity& verbosity);
 
 
void IndexAdd(// WS Generic Output:
              Index& out,
              // WS Generic Input:
              const Index& in,
              const Index& value,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void 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 irradiance_fieldFromRadiance(// WS Output:
                                  Tensor4& irradiance_field,
                                  // WS Input:
                                  const Tensor5& radiance_field,
                                  const Vector& za_grid,
                                  const Vector& aa_grid,
                                  const Vector& za_grid_weights,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void isotopologue_ratiosInitFromBuiltin(// WS Output:
                                        SpeciesIsotopologueRatios& isotopologue_ratios,
                                        // Verbosity object:
                                        const Verbosity& verbosity);
 
 
void isotopologue_ratiosInitFromHitran(// WS Output:
                                       SpeciesIsotopologueRatios& isotopologue_ratios,
                                       // WS Generic Input:
                                       const String& option,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void iyApplyUnit(// WS Output:
                 Matrix& iy,
                 ArrayOfMatrix& iy_aux,
                 // WS Input:
                 const Index& stokes_dim,
                 const Vector& f_grid,
                 const ArrayOfString& iy_aux_vars,
                 const String& iy_unit,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void iyCalc(// Workspace reference:
            Workspace& ws,
            // WS Output:
            Matrix& iy,
            ArrayOfMatrix& iy_aux,
            Ppath& ppath,
            // WS Input:
            const Index& atmgeom_checked,
            const Index& atmfields_checked,
            const ArrayOfString& iy_aux_vars,
            const Index& iy_id,
            const Index& cloudbox_on,
            const Index& cloudbox_checked,
            const Index& scat_data_checked,
            const Vector& f_grid,
            const EnergyLevelMap& nlte_field,
            const Vector& rte_pos,
            const Vector& rte_los,
            const Vector& rte_pos2,
            const String& iy_unit,
            const Agenda& iy_main_agenda,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void iyEmissionStandard(// Workspace reference:
                        Workspace& ws,
                        // WS Output:
                        Matrix& iy,
                        ArrayOfMatrix& iy_aux,
                        ArrayOfTensor3& diy_dx,
                        Vector& ppvar_p,
                        Vector& ppvar_t,
                        EnergyLevelMap& ppvar_nlte,
                        Matrix& ppvar_vmr,
                        Matrix& ppvar_wind,
                        Matrix& ppvar_mag,
                        Matrix& ppvar_f,
                        Tensor3& ppvar_iy,
                        Tensor4& ppvar_trans_cumulat,
                        Tensor4& ppvar_trans_partial,
                        // WS Input:
                        const Index& iy_id,
                        const Index& stokes_dim,
                        const Vector& f_grid,
                        const Index& atmosphere_dim,
                        const Vector& p_grid,
                        const Tensor3& t_field,
                        const EnergyLevelMap& nlte_field,
                        const Tensor4& vmr_field,
                        const ArrayOfArrayOfSpeciesTag& abs_species,
                        const Tensor3& wind_u_field,
                        const Tensor3& wind_v_field,
                        const Tensor3& wind_w_field,
                        const Tensor3& mag_u_field,
                        const Tensor3& mag_v_field,
                        const Tensor3& mag_w_field,
                        const Index& cloudbox_on,
                        const String& iy_unit,
                        const ArrayOfString& iy_aux_vars,
                        const Index& jacobian_do,
                        const ArrayOfRetrievalQuantity& jacobian_quantities,
                        const Ppath& ppath,
                        const Vector& rte_pos2,
                        const Agenda& propmat_clearsky_agenda,
                        const Agenda& water_p_eq_agenda,
                        const String& rt_integration_option,
                        const Agenda& iy_main_agenda,
                        const Agenda& iy_space_agenda,
                        const Agenda& iy_surface_agenda,
                        const Agenda& iy_cloudbox_agenda,
                        const Index& iy_agenda_call1,
                        const Tensor3& iy_transmittance,
                        const Numeric& rte_alonglos_v,
                        const Tensor3& surface_props_data,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void iyHybrid(// Workspace reference:
              Workspace& ws,
              // WS Output:
              Matrix& iy,
              ArrayOfMatrix& iy_aux,
              ArrayOfTensor3& diy_dx,
              Vector& ppvar_p,
              Vector& ppvar_t,
              EnergyLevelMap& ppvar_nlte,
              Matrix& ppvar_vmr,
              Matrix& ppvar_wind,
              Matrix& ppvar_mag,
              Matrix& ppvar_pnd,
              Matrix& ppvar_f,
              Tensor3& ppvar_iy,
              Tensor4& ppvar_trans_cumulat,
              Tensor4& ppvar_trans_partial,
              // WS Input:
              const Index& iy_id,
              const Index& stokes_dim,
              const Vector& f_grid,
              const Index& atmosphere_dim,
              const Vector& p_grid,
              const Tensor3& t_field,
              const EnergyLevelMap& nlte_field,
              const Tensor4& vmr_field,
              const ArrayOfArrayOfSpeciesTag& abs_species,
              const Tensor3& wind_u_field,
              const Tensor3& wind_v_field,
              const Tensor3& wind_w_field,
              const Tensor3& mag_u_field,
              const Tensor3& mag_v_field,
              const Tensor3& mag_w_field,
              const Index& cloudbox_on,
              const ArrayOfIndex& cloudbox_limits,
              const Tensor4& pnd_field,
              const ArrayOfTensor4& dpnd_field_dx,
              const ArrayOfString& scat_species,
              const ArrayOfArrayOfSingleScatteringData& scat_data,
              const String& iy_unit,
              const ArrayOfString& iy_aux_vars,
              const Index& jacobian_do,
              const ArrayOfRetrievalQuantity& jacobian_quantities,
              const Agenda& propmat_clearsky_agenda,
              const Agenda& water_p_eq_agenda,
              const String& rt_integration_option,
              const Agenda& iy_main_agenda,
              const Agenda& iy_space_agenda,
              const Agenda& iy_surface_agenda,
              const Agenda& iy_cloudbox_agenda,
              const Index& iy_agenda_call1,
              const Tensor3& iy_transmittance,
              const Ppath& ppath,
              const Vector& rte_pos2,
              const Numeric& rte_alonglos_v,
              const Tensor3& surface_props_data,
              const Tensor7& cloudbox_field,
              const Vector& za_grid,
              // WS Generic Input:
              const Index& Naa_grid,
              const Index& t_interp_order,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void iyIndependentBeamApproximation(// Workspace reference:
                                    Workspace& ws,
                                    // WS Output:
                                    Matrix& iy,
                                    ArrayOfMatrix& iy_aux,
                                    Ppath& ppath,
                                    ArrayOfTensor3& diy_dx,
                                    GriddedField4& atm_fields_compact,
                                    // WS Input:
                                    const Index& iy_id,
                                    const Vector& f_grid,
                                    const Index& atmosphere_dim,
                                    const Vector& p_grid,
                                    const Vector& lat_grid,
                                    const Vector& lon_grid,
                                    const Vector& lat_true,
                                    const Vector& lon_true,
                                    const Tensor3& t_field,
                                    const Tensor3& z_field,
                                    const Tensor4& vmr_field,
                                    const EnergyLevelMap& nlte_field,
                                    const Tensor3& wind_u_field,
                                    const Tensor3& wind_v_field,
                                    const Tensor3& wind_w_field,
                                    const Tensor3& mag_u_field,
                                    const Tensor3& mag_v_field,
                                    const Tensor3& mag_w_field,
                                    const Index& cloudbox_on,
                                    const ArrayOfIndex& cloudbox_limits,
                                    const Tensor4& pnd_field,
                                    const Matrix& particle_masses,
                                    const Agenda& ppath_agenda,
                                    const Numeric& ppath_lmax,
                                    const Numeric& ppath_lraytrace,
                                    const Index& iy_agenda_call1,
                                    const String& iy_unit,
                                    const Tensor3& iy_transmittance,
                                    const Vector& rte_pos,
                                    const Vector& rte_los,
                                    const Vector& rte_pos2,
                                    const Index& jacobian_do,
                                    const ArrayOfString& iy_aux_vars,
                                    const Agenda& iy_independent_beam_approx_agenda,
                                    // WS Generic Input:
                                    const Index& return_atm1d,
                                    const Index& skip_vmr,
                                    const Index& skip_pnd,
                                    const Index& return_masses,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void iyInterpCloudboxField(// WS Output:
                           Matrix& iy,
                           // WS Input:
                           const Tensor7& cloudbox_field,
                           const Vector& rtp_pos,
                           const Vector& rtp_los,
                           const Index& jacobian_do,
                           const Index& cloudbox_on,
                           const ArrayOfIndex& cloudbox_limits,
                           const Index& atmosphere_dim,
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           const Tensor3& z_field,
                           const Matrix& z_surface,
                           const Index& stokes_dim,
                           const Vector& za_grid,
                           const Vector& aa_grid,
                           const Vector& f_grid,
                           // WS Generic Input:
                           const Index& za_interp_order,
                           const Index& za_restrict,
                           const Index& cos_za_interp,
                           const Numeric& za_extpolfac,
                           const Index& aa_interp_order,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void iyLoopFrequencies(// Workspace reference:
                       Workspace& ws,
                       // WS Output:
                       Matrix& iy,
                       ArrayOfMatrix& iy_aux,
                       Ppath& ppath,
                       ArrayOfTensor3& diy_dx,
                       // WS Input:
                       const ArrayOfString& iy_aux_vars,
                       const Index& iy_agenda_call1,
                       const Tensor3& iy_transmittance,
                       const Vector& rte_pos,
                       const Vector& rte_los,
                       const Vector& rte_pos2,
                       const Index& stokes_dim,
                       const Vector& f_grid,
                       const Agenda& iy_loop_freqs_agenda,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void iyMC(// Workspace reference:
          Workspace& ws,
          // WS Output:
          Matrix& iy,
          ArrayOfMatrix& iy_aux,
          ArrayOfTensor3& diy_dx,
          // WS Input:
          const Index& iy_agenda_call1,
          const Tensor3& iy_transmittance,
          const Vector& rte_pos,
          const Vector& rte_los,
          const ArrayOfString& iy_aux_vars,
          const Index& jacobian_do,
          const Index& atmosphere_dim,
          const Vector& p_grid,
          const Vector& lat_grid,
          const Vector& lon_grid,
          const Tensor3& z_field,
          const Tensor3& t_field,
          const Tensor4& vmr_field,
          const Vector& refellipsoid,
          const Matrix& z_surface,
          const Index& cloudbox_on,
          const ArrayOfIndex& cloudbox_limits,
          const Index& stokes_dim,
          const Vector& f_grid,
          const ArrayOfArrayOfSingleScatteringData& scat_data,
          const Agenda& iy_space_agenda,
          const Agenda& surface_rtprop_agenda,
          const Agenda& propmat_clearsky_agenda,
          const Agenda& ppath_step_agenda,
          const Numeric& ppath_lmax,
          const Numeric& ppath_lraytrace,
          const Tensor4& pnd_field,
          const String& iy_unit,
          const Numeric& mc_std_err,
          const Index& mc_max_time,
          const Index& mc_max_iter,
          const Index& mc_min_iter,
          const Numeric& mc_taustep_limit,
          // WS Generic Input:
          const Index& t_interp_order,
          // Verbosity object:
          const Verbosity& verbosity);
 
 
void iyRadarSingleScat(// Workspace reference:
                       Workspace& ws,
                       // WS Output:
                       Matrix& iy,
                       ArrayOfMatrix& iy_aux,
                       ArrayOfTensor3& diy_dx,
                       Vector& ppvar_p,
                       Vector& ppvar_t,
                       Matrix& ppvar_vmr,
                       Matrix& ppvar_wind,
                       Matrix& ppvar_mag,
                       Matrix& ppvar_pnd,
                       Matrix& ppvar_f,
                       // WS Input:
                       const Index& stokes_dim,
                       const Vector& f_grid,
                       const Index& atmosphere_dim,
                       const Vector& p_grid,
                       const Tensor3& t_field,
                       const EnergyLevelMap& nlte_field,
                       const Tensor4& vmr_field,
                       const ArrayOfArrayOfSpeciesTag& abs_species,
                       const Tensor3& wind_u_field,
                       const Tensor3& wind_v_field,
                       const Tensor3& wind_w_field,
                       const Tensor3& mag_u_field,
                       const Tensor3& mag_v_field,
                       const Tensor3& mag_w_field,
                       const Index& cloudbox_on,
                       const ArrayOfIndex& cloudbox_limits,
                       const Tensor4& pnd_field,
                       const ArrayOfTensor4& dpnd_field_dx,
                       const ArrayOfString& scat_species,
                       const ArrayOfArrayOfSingleScatteringData& scat_data,
                       const Index& scat_data_checked,
                       const ArrayOfString& iy_aux_vars,
                       const Index& jacobian_do,
                       const ArrayOfRetrievalQuantity& jacobian_quantities,
                       const Ppath& ppath,
                       const Agenda& propmat_clearsky_agenda,
                       const Agenda& water_p_eq_agenda,
                       const Agenda& iy_transmitter_agenda,
                       const Numeric& rte_alonglos_v,
                       // WS Generic Input:
                       const Index& trans_in_jacobian,
                       const Numeric& pext_scaling,
                       const Index& t_interp_order,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void iyReplaceFromAux(// WS Output:
                      Matrix& iy,
                      // WS Input:
                      const ArrayOfMatrix& iy_aux,
                      const ArrayOfString& iy_aux_vars,
                      const Index& jacobian_do,
                      // WS Generic Input:
                      const String& aux_var,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void iySurfaceCallAgendaX(// Workspace reference:
                          Workspace& ws,
                          // WS Output:
                          Matrix& iy,
                          ArrayOfTensor3& diy_dx,
                          // WS Input:
                          const String& iy_unit,
                          const Tensor3& iy_transmittance,
                          const Index& iy_id,
                          const Index& cloudbox_on,
                          const Index& jacobian_do,
                          const Vector& f_grid,
                          const Agenda& iy_main_agenda,
                          const Vector& rtp_pos,
                          const Vector& rtp_los,
                          const Vector& rte_pos2,
                          const ArrayOfAgenda& iy_surface_agenda_array,
                          const ArrayOfIndex& surface_types,
                          const Vector& surface_types_aux,
                          const Vector& surface_types_weights,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void iySurfaceFastem(// Workspace reference:
                     Workspace& ws,
                     // WS Output:
                     Matrix& iy,
                     ArrayOfTensor3& diy_dx,
                     // WS Input:
                     const Tensor3& iy_transmittance,
                     const Index& iy_id,
                     const Index& jacobian_do,
                     const Index& atmosphere_dim,
                     const EnergyLevelMap& nlte_field,
                     const Index& cloudbox_on,
                     const Index& stokes_dim,
                     const Vector& f_grid,
                     const Vector& rtp_pos,
                     const Vector& rtp_los,
                     const Vector& rte_pos2,
                     const String& iy_unit,
                     const Agenda& iy_main_agenda,
                     const Numeric& surface_skin_t,
                     // WS Generic Input:
                     const Numeric& salinity,
                     const Numeric& wind_speed,
                     const Numeric& wind_direction,
                     const Index& fastem_version,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void iySurfaceRtpropAgenda(// Workspace reference:
                           Workspace& ws,
                           // WS Output:
                           Matrix& iy,
                           ArrayOfTensor3& diy_dx,
                           Numeric& surface_skin_t,
                           Matrix& surface_los,
                           Tensor4& surface_rmatrix,
                           Matrix& surface_emission,
                           // WS Input:
                           const Tensor3& iy_transmittance,
                           const Index& iy_id,
                           const Index& jacobian_do,
                           const Index& atmosphere_dim,
                           const EnergyLevelMap& nlte_field,
                           const Index& cloudbox_on,
                           const Index& stokes_dim,
                           const Vector& f_grid,
                           const Vector& rtp_pos,
                           const Vector& rtp_los,
                           const Vector& rte_pos2,
                           const String& iy_unit,
                           const Agenda& iy_main_agenda,
                           const Agenda& surface_rtprop_agenda,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void iySurfaceRtpropCalc(// Workspace reference:
                         Workspace& ws,
                         // WS Output:
                         Matrix& iy,
                         ArrayOfTensor3& diy_dx,
                         // WS Input:
                         const Matrix& surface_los,
                         const Tensor4& surface_rmatrix,
                         const Matrix& surface_emission,
                         const ArrayOfString& dsurface_names,
                         const ArrayOfTensor4& dsurface_rmatrix_dx,
                         const ArrayOfMatrix& dsurface_emission_dx,
                         const Tensor3& iy_transmittance,
                         const Index& iy_id,
                         const Index& jacobian_do,
                         const ArrayOfRetrievalQuantity& jacobian_quantities,
                         const Index& atmosphere_dim,
                         const EnergyLevelMap& nlte_field,
                         const Index& cloudbox_on,
                         const Index& stokes_dim,
                         const Vector& f_grid,
                         const Vector& rtp_pos,
                         const Vector& rtp_los,
                         const Vector& rte_pos2,
                         const String& iy_unit,
                         const Agenda& iy_main_agenda,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void iyTransmissionStandard(// Workspace reference:
                            Workspace& ws,
                            // WS Output:
                            Matrix& iy,
                            ArrayOfMatrix& iy_aux,
                            ArrayOfTensor3& diy_dx,
                            Vector& ppvar_p,
                            Vector& ppvar_t,
                            EnergyLevelMap& ppvar_nlte,
                            Matrix& ppvar_vmr,
                            Matrix& ppvar_wind,
                            Matrix& ppvar_mag,
                            Matrix& ppvar_pnd,
                            Matrix& ppvar_f,
                            Tensor3& ppvar_iy,
                            Tensor4& ppvar_trans_cumulat,
                            Tensor4& ppvar_trans_partial,
                            // WS Input:
                            const Index& stokes_dim,
                            const Vector& f_grid,
                            const Index& atmosphere_dim,
                            const Vector& p_grid,
                            const Tensor3& t_field,
                            const EnergyLevelMap& nlte_field,
                            const Tensor4& vmr_field,
                            const ArrayOfArrayOfSpeciesTag& abs_species,
                            const Tensor3& wind_u_field,
                            const Tensor3& wind_v_field,
                            const Tensor3& wind_w_field,
                            const Tensor3& mag_u_field,
                            const Tensor3& mag_v_field,
                            const Tensor3& mag_w_field,
                            const Index& cloudbox_on,
                            const ArrayOfIndex& cloudbox_limits,
                            const Tensor4& pnd_field,
                            const ArrayOfTensor4& dpnd_field_dx,
                            const ArrayOfString& scat_species,
                            const ArrayOfArrayOfSingleScatteringData& scat_data,
                            const ArrayOfString& iy_aux_vars,
                            const Index& jacobian_do,
                            const ArrayOfRetrievalQuantity& jacobian_quantities,
                            const Ppath& ppath,
                            const Agenda& propmat_clearsky_agenda,
                            const Agenda& water_p_eq_agenda,
                            const Agenda& iy_transmitter_agenda,
                            const Index& iy_agenda_call1,
                            const Tensor3& iy_transmittance,
                            const Numeric& rte_alonglos_v,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void iy_transmitterMultiplePol(// WS Output:
                               Matrix& iy,
                               // WS Input:
                               const Index& stokes_dim,
                               const Vector& f_grid,
                               const ArrayOfIndex& instrument_pol,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void iy_transmitterSinglePol(// WS Output:
                             Matrix& iy,
                             // WS Input:
                             const Index& stokes_dim,
                             const Vector& f_grid,
                             const ArrayOfIndex& instrument_pol,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void jacobianAddAbsSpecies(// Workspace reference:
                           Workspace& ws,
                           // WS Output:
                           ArrayOfRetrievalQuantity& jacobian_quantities,
                           Agenda& jacobian_agenda,
                           // WS Input:
                           const Index& atmosphere_dim,
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           // WS Generic Input:
                           const Vector& g1,
                           const Vector& g2,
                           const Vector& g3,
                           const String& species,
                           const String& unit,
                           const Index& for_species_tag,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void jacobianAddBasicCatalogParameter(// Workspace reference:
                                      Workspace& ws,
                                      // WS Output:
                                      ArrayOfRetrievalQuantity& jacobian_quantities,
                                      Agenda& jacobian_agenda,
                                      // WS Generic Input:
                                      const QuantumIdentifier& catalog_identity,
                                      const String& catalog_parameter,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void jacobianAddBasicCatalogParameters(// Workspace reference:
                                       Workspace& ws,
                                       // WS Output:
                                       ArrayOfRetrievalQuantity& jacobian_quantities,
                                       Agenda& jacobian_agenda,
                                       // WS Generic Input:
                                       const ArrayOfQuantumIdentifier& catalog_identities,
                                       const ArrayOfString& catalog_parameters,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void jacobianAddFreqShift(// Workspace reference:
                          Workspace& ws,
                          // WS Output:
                          ArrayOfRetrievalQuantity& jacobian_quantities,
                          Agenda& jacobian_agenda,
                          // WS Input:
                          const Vector& f_grid,
                          // WS Generic Input:
                          const Numeric& df,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void jacobianAddFreqStretch(// Workspace reference:
                            Workspace& ws,
                            // WS Output:
                            ArrayOfRetrievalQuantity& jacobian_quantities,
                            Agenda& jacobian_agenda,
                            // WS Input:
                            const Vector& f_grid,
                            // WS Generic Input:
                            const Numeric& df,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void jacobianAddShapeCatalogParameter(// Workspace reference:
                                      Workspace& ws,
                                      // WS Output:
                                      ArrayOfRetrievalQuantity& jacobian_quantities,
                                      Agenda& jacobian_agenda,
                                      // WS Generic Input:
                                      const QuantumIdentifier& line_identity,
                                      const String& species,
                                      const String& variable,
                                      const String& coefficient,
                                      // Verbosity object: