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: Feb  4 2009, 08:16:40

#ifndef auto_md_h
#define auto_md_h

#include "matpackI.h"
#include "los.h"
#include "absorption.h"
#include "auto_wsv.h"
#include "parser.h"

// This is only used for a consistency check. You can get the
// number of workspace variables from wsv_data.nelem().
#define N_MD 158

enum MdHandle{
  Echo_,
  Exit_,
  Test_,
  IndexSet_,
  IndexWriteAscii_,
  IndexReadAscii_,
  IndexWriteBinary_,
  IndexReadBinary_,
  NumericSet_,
  NumericCopyFirstOfVector_,
  NumericCopyLastOfVector_,
  NumericWriteAscii_,
  NumericReadAscii_,
  NumericWriteBinary_,
  NumericReadBinary_,
  VectorCopy_,
  VectorCopyFromMatrix_,
  VectorSet_,
  VectorSetLengthFromVector_,
  VectorLinSpace_,
  VectorNLinSpace_,
  VectorNLogSpace_,
  VectorPressuresForLinAltitudes_,
  VectorFlip_,
  VectorMatrixMultiply_,
  VectorWriteAscii_,
  VectorReadAscii_,
  VectorWriteBinary_,
  VectorReadBinary_,
  VectorPlanck_,
  VectorCalcLog10_,
  VectorAdd_,
  VectorScale_,
  MatrixSet_,
  MatrixCopy_,
  MatrixFillWithVector_,
  MatrixMatrixMultiply_,
  ArrayOfMatrixMatrixMultiply_,
  MatrixMatrixAdd_,
  MatrixWriteAscii_,
  MatrixReadAscii_,
  MatrixWriteBinary_,
  MatrixReadBinary_,
  MatrixScale_,
  MatrixDiagonal_,
  ArrayOfIndexWriteAscii_,
  ArrayOfIndexReadAscii_,
  ArrayOfIndexWriteBinary_,
  ArrayOfIndexReadBinary_,
  ArrayOfVectorWriteAscii_,
  ArrayOfVectorReadAscii_,
  ArrayOfVectorWriteBinary_,
  ArrayOfVectorReadBinary_,
  ArrayOfMatrixWriteAscii_,
  ArrayOfMatrixReadAscii_,
  ArrayOfMatrixWriteBinary_,
  ArrayOfMatrixReadBinary_,
  StringSet_,
  StringWriteAscii_,
  StringReadAscii_,
  StringWriteBinary_,
  StringReadBinary_,
  ArrayOfStringSet_,
  ArrayOfStringWriteAscii_,
  ArrayOfStringReadAscii_,
  ArrayOfStringWriteBinary_,
  ArrayOfStringReadBinary_,
  TagGroupsSpeciesWriteAscii_,
  LosWriteBinary_,
  LosReadBinary_,
  lines_per_tgSetEmpty_,
  lines_per_tgReadFromCatalogues_,
  linesReadFromHitran_,
  linesReadFromHitran2004_,
  linesReadFromMytran2_,
  linesReadFromJpl_,
  linesReadFromArts_,
  linesElowToJoule_,
  lines_per_tgCreateFromLines_,
  lines_per_tgAddMirrorLines_,
  lines_per_tgCompact_,
  linesWriteAscii_,
  lines_per_tgWriteAscii_,
  tgsDefine_,
  tgsDefineAllInScenario_,
  lineshapeDefine_,
  lineshape_per_tgDefine_,
  cont_descriptionInit_,
  cont_descriptionAppend_,
  raw_vmrsReadFromFiles_,
  raw_vmrsReadFromScenario_,
  AtmFromRaw_,
  WaterVaporSaturationInClouds_,
  vmrsScale_,
  h2o_absSet_,
  n2_absSet_,
  hseSet_,
  hseSetFromLatitude_,
  hseSetFromLatitudeIndex_,
  hseFromBottom_,
  hseOff_,
  hseCalc_,
  absCalc_,
  absCalcSaveMemory_,
  absCalcFromXsec_,
  xsec_per_tgInit_,
  xsec_per_tgAddLines_,
  xsec_per_tgAddConts_,
  abs_per_tgReduce_,
  refrSet_,
  refrOff_,
  refrCalc_,
  zaFromZtan_,
  zaFromDeltat_,
  r_geoidStd_,
  r_geoidWGS84_,
  groundOff_,
  groundSet_,
  groundAtBottom_,
  groundFlatSea_,
  emissionOn_,
  emissionOff_,
  losCalc_,
  sourceCalc_,
  transCalc_,
  y_spaceStd_,
  yCalc_,
  sourcetransyCalcSaveMemory_,
  CoolingRates_,
  yTB_,
  MatrixTB_,
  yTRJ_,
  MatrixTRJ_,
  wfs_tgsDefine_,
  wfss_tgsDefine_,
  absloswfsCalc_,
  kSpecies_,
  kSpeciesSingle_,
  kContAbs_,
  kTemp_,
  kSpectro_,
  kFrequencyOffSet_,
  kPointingOffSet_,
  kEground_,
  kCalibration_,
  kManual_,
  kxInit_,
  kbInit_,
  kxAppend_,
  kbAppend_,
  kxAllocate_,
  kbAllocate_,
  kxPutInK_,
  kbPutInK_,
  ybatchCalc_,
  ybatchFromRadiosonde_,
  ybatchFromRadiosondeGlobal_,
  MethodListDefine_
};

// Method function declarations:

void Echo(// Control Parameters:
          const String& message,
          const Index& level);

void Exit();

void Test();

void IndexSet(// WS Generic Output:
              Index&,
              // WS Generic Output Names:
              const String&,
              // Control Parameters:
              const Index& value);

void IndexWriteAscii(// WS Generic Input:
                     const Index&,
                     // WS Generic Input Names:
                     const String&,
                     // Control Parameters:
                     const String& filename);

void IndexReadAscii(// WS Generic Output:
                    Index&,
                    // WS Generic Output Names:
                    const String&,
                    // Control Parameters:
                    const String& filename);

void IndexWriteBinary(// WS Generic Input:
                      const Index&,
                      // WS Generic Input Names:
                      const String&,
                      // Control Parameters:
                      const String& filename);

void IndexReadBinary(// WS Generic Output:
                     Index&,
                     // WS Generic Output Names:
                     const String&,
                     // Control Parameters:
                     const String& filename);

void NumericSet(// WS Generic Output:
                Numeric&,
                // WS Generic Output Names:
                const String&,
                // Control Parameters:
                const Numeric& value);

void NumericCopyFirstOfVector(// WS Generic Output:
                              Numeric&,
                              // WS Generic Output Names:
                              const String&,
                              // WS Generic Input:
                              const Vector&,
                              // WS Generic Input Names:
                              const String&);

void NumericCopyLastOfVector(// WS Generic Output:
                             Numeric&,
                             // WS Generic Output Names:
                             const String&,
                             // WS Generic Input:
                             const Vector&,
                             // WS Generic Input Names:
                             const String&);

void NumericWriteAscii(// WS Generic Input:
                       const Numeric&,
                       // WS Generic Input Names:
                       const String&,
                       // Control Parameters:
                       const String& filename);

void NumericReadAscii(// WS Generic Output:
                      Numeric&,
                      // WS Generic Output Names:
                      const String&,
                      // Control Parameters:
                      const String& filename);

void NumericWriteBinary(// WS Generic Input:
                        const Numeric&,
                        // WS Generic Input Names:
                        const String&,
                        // Control Parameters:
                        const String& filename);

void NumericReadBinary(// WS Generic Output:
                       Numeric&,
                       // WS Generic Output Names:
                       const String&,
                       // Control Parameters:
                       const String& filename);

void VectorCopy(// WS Generic Output:
                Vector&,
                // WS Generic Output Names:
                const String&,
                // WS Generic Input:
                const Vector&,
                // WS Generic Input Names:
                const String&);

void VectorCopyFromMatrix(// WS Generic Output:
                          Vector&,
                          // WS Generic Output Names:
                          const String&,
                          // WS Generic Input:
                          const Matrix&,
                          // WS Generic Input Names:
                          const String&,
                          // Control Parameters:
                          const String& orientation,
                          const Index& index);

void VectorSet(// WS Generic Output:
               Vector&,
               // WS Generic Output Names:
               const String&,
               // Control Parameters:
               const Index& length,
               const Numeric& value);

void VectorSetLengthFromVector(// WS Generic Output:
                               Vector&,
                               // WS Generic Output Names:
                               const String&,
                               // WS Generic Input:
                               const Vector&,
                               // WS Generic Input Names:
                               const String&,
                               // Control Parameters:
                               const Numeric& value);

void VectorLinSpace(// WS Generic Output:
                    Vector&,
                    // WS Generic Output Names:
                    const String&,
                    // Control Parameters:
                    const Numeric& start,
                    const Numeric& stop,
                    const Numeric& step);

void VectorNLinSpace(// WS Generic Output:
                     Vector&,
                     // WS Generic Output Names:
                     const String&,
                     // Control Parameters:
                     const Numeric& start,
                     const Numeric& stop,
                     const Index& n);

void VectorNLogSpace(// WS Generic Output:
                     Vector&,
                     // WS Generic Output Names:
                     const String&,
                     // Control Parameters:
                     const Numeric& start,
                     const Numeric& stop,
                     const Index& n);

void VectorPressuresForLinAltitudes(// WS Generic Output:
                                    Vector&,
                                    // WS Generic Output Names:
                                    const String&,
                                    // WS Input:
                                    const Vector&,
                                    const Vector&,
                                    // Control Parameters:
                                    const Numeric& delta_z,
                                    const Numeric& p_start,
                                    const Numeric& p_stop);

void VectorFlip(// WS Generic Output:
                Vector&,
                // WS Generic Output Names:
                const String&,
                // WS Generic Input:
                const Vector&,
                // WS Generic Input Names:
                const String&);

void VectorMatrixMultiply(// WS Generic Output:
                          Vector&,
                          // WS Generic Output Names:
                          const String&,
                          // WS Generic Input:
                          const Matrix&,
                          const Vector&,
                          // WS Generic Input Names:
                          const String&,
                          const String&);

void VectorWriteAscii(// WS Generic Input:
                      const Vector&,
                      // WS Generic Input Names:
                      const String&,
                      // Control Parameters:
                      const String& filename);

void VectorReadAscii(// WS Generic Output:
                     Vector&,
                     // WS Generic Output Names:
                     const String&,
                     // Control Parameters:
                     const String& filename);

void VectorWriteBinary(// WS Generic Input:
                       const Vector&,
                       // WS Generic Input Names:
                       const String&,
                       // Control Parameters:
                       const String& filename);

void VectorReadBinary(// WS Generic Output:
                      Vector&,
                      // WS Generic Output Names:
                      const String&,
                      // Control Parameters:
                      const String& filename);

void VectorPlanck(// WS Generic Output:
                  Vector&,
                  // WS Generic Output Names:
                  const String&,
                  // WS Generic Input:
                  const Vector&,
                  // WS Generic Input Names:
                  const String&,
                  // Control Parameters:
                  const Numeric& temp);

void VectorCalcLog10(// WS Generic Output:
                     Vector&,
                     // WS Generic Output Names:
                     const String&,
                     // WS Generic Input:
                     const Vector&,
                     // WS Generic Input Names:
                     const String&);

void VectorAdd(// WS Generic Output:
               Vector&,
               // WS Generic Output Names:
               const String&,
               // WS Generic Input:
               const Vector&,
               // WS Generic Input Names:
               const String&,
               // Control Parameters:
               const Numeric& value);

void VectorScale(// WS Generic Output:
                 Vector&,
                 // WS Generic Output Names:
                 const String&,
                 // WS Generic Input:
                 const Vector&,
                 // WS Generic Input Names:
                 const String&,
                 // Control Parameters:
                 const Numeric& value);

void MatrixSet(// WS Generic Output:
               Matrix&,
               // WS Generic Output Names:
               const String&,
               // Control Parameters:
               const Index& nrows,
               const Index& ncols,
               const Numeric& value);

void MatrixCopy(// WS Generic Output:
                Matrix&,
                // WS Generic Output Names:
                const String&,
                // WS Generic Input:
                const Matrix&,
                // WS Generic Input Names:
                const String&);

void MatrixFillWithVector(// WS Generic Output:
                          Matrix&,
                          // WS Generic Output Names:
                          const String&,
                          // WS Generic Input:
                          const Vector&,
                          // WS Generic Input Names:
                          const String&,
                          // Control Parameters:
                          const Index& n);

void MatrixMatrixMultiply(// WS Generic Output:
                          Matrix&,
                          // WS Generic Output Names:
                          const String&,
                          // WS Generic Input:
                          const Matrix&,
                          const Matrix&,
                          // WS Generic Input Names:
                          const String&,
                          const String&);

void ArrayOfMatrixMatrixMultiply(// WS Generic Output:
                                 ArrayOfMatrix&,
                                 // WS Generic Output Names:
                                 const String&,
                                 // WS Generic Input:
                                 const Matrix&,
                                 const ArrayOfMatrix&,
                                 // WS Generic Input Names:
                                 const String&,
                                 const String&);

void MatrixMatrixAdd(// WS Generic Output:
                     Matrix&,
                     // WS Generic Output Names:
                     const String&,
                     // WS Generic Input:
                     const Matrix&,
                     const Matrix&,
                     // WS Generic Input Names:
                     const String&,
                     const String&);

void MatrixWriteAscii(// WS Generic Input:
                      const Matrix&,
                      // WS Generic Input Names:
                      const String&,
                      // Control Parameters:
                      const String& filename);

void MatrixReadAscii(// WS Generic Output:
                     Matrix&,
                     // WS Generic Output Names:
                     const String&,
                     // Control Parameters:
                     const String& filename);

void MatrixWriteBinary(// WS Generic Input:
                       const Matrix&,
                       // WS Generic Input Names:
                       const String&,
                       // Control Parameters:
                       const String& filename);

void MatrixReadBinary(// WS Generic Output:
                      Matrix&,
                      // WS Generic Output Names:
                      const String&,
                      // Control Parameters:
                      const String& filename);

void MatrixScale(// WS Generic Output:
                 Matrix&,
                 // WS Generic Output Names:
                 const String&,
                 // WS Generic Input:
                 const Matrix&,
                 // WS Generic Input Names:
                 const String&,
                 // Control Parameters:
                 const Numeric& value);

void MatrixDiagonal(// WS Generic Output:
                    Matrix&,
                    // WS Generic Output Names:
                    const String&,
                    // Control Parameters:
                    const Index& nrows,
                    const Numeric& value);

void ArrayOfIndexWriteAscii(// WS Generic Input:
                            const ArrayOfIndex&,
                            // WS Generic Input Names:
                            const String&,
                            // Control Parameters:
                            const String& filename);

void ArrayOfIndexReadAscii(// WS Generic Output:
                           ArrayOfIndex&,
                           // WS Generic Output Names:
                           const String&,
                           // Control Parameters:
                           const String& filename);

void ArrayOfIndexWriteBinary(// WS Generic Input:
                             const ArrayOfIndex&,
                             // WS Generic Input Names:
                             const String&,
                             // Control Parameters:
                             const String& filename);

void ArrayOfIndexReadBinary(// WS Generic Output:
                            ArrayOfIndex&,
                            // WS Generic Output Names:
                            const String&,
                            // Control Parameters:
                            const String& filename);

void ArrayOfVectorWriteAscii(// WS Generic Input:
                             const ArrayOfVector&,
                             // WS Generic Input Names:
                             const String&,
                             // Control Parameters:
                             const String& filename);

void ArrayOfVectorReadAscii(// WS Generic Output:
                            ArrayOfVector&,
                            // WS Generic Output Names:
                            const String&,
                            // Control Parameters:
                            const String& filename);

void ArrayOfVectorWriteBinary(// WS Generic Input:
                              const ArrayOfVector&,
                              // WS Generic Input Names:
                              const String&,
                              // Control Parameters:
                              const String& filename);

void ArrayOfVectorReadBinary(// WS Generic Output:
                             ArrayOfVector&,
                             // WS Generic Output Names:
                             const String&,
                             // Control Parameters:
                             const String& filename);

void ArrayOfMatrixWriteAscii(// WS Generic Input:
                             const ArrayOfMatrix&,
                             // WS Generic Input Names:
                             const String&,
                             // Control Parameters:
                             const String& filename);

void ArrayOfMatrixReadAscii(// WS Generic Output:
                            ArrayOfMatrix&,
                            // WS Generic Output Names:
                            const String&,
                            // Control Parameters:
                            const String& filename);

void ArrayOfMatrixWriteBinary(// WS Generic Input:
                              const ArrayOfMatrix&,
                              // WS Generic Input Names:
                              const String&,
                              // Control Parameters:
                              const String& filename);

void ArrayOfMatrixReadBinary(// WS Generic Output:
                             ArrayOfMatrix&,
                             // WS Generic Output Names:
                             const String&,
                             // Control Parameters:
                             const String& filename);

void StringSet(// WS Generic Output:
               String&,
               // WS Generic Output Names:
               const String&,
               // Control Parameters:
               const String& text);

void StringWriteAscii(// WS Generic Input:
                      const String&,
                      // WS Generic Input Names:
                      const String&,
                      // Control Parameters:
                      const String& filename);

void StringReadAscii(// WS Generic Output:
                     String&,
                     // WS Generic Output Names:
                     const String&,
                     // Control Parameters:
                     const String& filename);

void StringWriteBinary(// WS Generic Input:
                       const String&,
                       // WS Generic Input Names:
                       const String&,
                       // Control Parameters:
                       const String& filename);

void StringReadBinary(// WS Generic Output:
                      String&,
                      // WS Generic Output Names:
                      const String&,
                      // Control Parameters:
                      const String& filename);

void ArrayOfStringSet(// WS Generic Output:
                      ArrayOfString&,
                      // WS Generic Output Names:
                      const String&,
                      // Control Parameters:
                      const ArrayOfString& text);

void ArrayOfStringWriteAscii(// WS Generic Input:
                             const ArrayOfString&,
                             // WS Generic Input Names:
                             const String&,
                             // Control Parameters:
                             const String& filename);

void ArrayOfStringReadAscii(// WS Generic Output:
                            ArrayOfString&,
                            // WS Generic Output Names:
                            const String&,
                            // Control Parameters:
                            const String& filename);

void ArrayOfStringWriteBinary(// WS Generic Input:
                              const ArrayOfString&,
                              // WS Generic Input Names:
                              const String&,
                              // Control Parameters:
                              const String& filename);

void ArrayOfStringReadBinary(// WS Generic Output:
                             ArrayOfString&,
                             // WS Generic Output Names:
                             const String&,
                             // Control Parameters:
                             const String& filename);

void TagGroupsSpeciesWriteAscii(// WS Generic Input:
                                const TagGroups&,
                                // WS Generic Input Names:
                                const String&,
                                // Control Parameters:
                                const String& filename);

void LosWriteBinary(// WS Generic Input:
                    const Los&,
                    // WS Generic Input Names:
                    const String&,
                    // Control Parameters:
                    const String& filename);

void LosReadBinary(// WS Generic Output:
                   Los&,
                   // WS Generic Output Names:
                   const String&,
                   // Control Parameters:
                   const String& filename);

void lines_per_tgSetEmpty(// WS Output:
                          ArrayOfArrayOfLineRecord&,
                          // WS Input:
                          const TagGroups&);

void lines_per_tgReadFromCatalogues(// WS Output:
                                    ArrayOfArrayOfLineRecord&,
                                    // WS Input:
                                    const TagGroups&,
                                    // Control Parameters:
                                    const ArrayOfString& filenames,
                                    const ArrayOfString& formats,
                                    const Vector& fmin,
                                    const Vector& fmax);

void linesReadFromHitran(// WS Output:
                         ArrayOfLineRecord&,
                         // Control Parameters:
                         const String& filename,
                         const Numeric& fmin,
                         const Numeric& fmax);

void linesReadFromHitran2004(// WS Output:
                             ArrayOfLineRecord&,
                             // Control Parameters:
                             const String& filename,
                             const Numeric& fmin,
                             const Numeric& fmax);

void linesReadFromMytran2(// WS Output:
                          ArrayOfLineRecord&,
                          // Control Parameters:
                          const String& filename,
                          const Numeric& fmin,
                          const Numeric& fmax);

void linesReadFromJpl(// WS Output:
                      ArrayOfLineRecord&,
                      // Control Parameters:
                      const String& filename,
                      const Numeric& fmin,
                      const Numeric& fmax);

void linesReadFromArts(// WS Output:
                       ArrayOfLineRecord&,
                       // Control Parameters:
                       const String& filename,
                       const Numeric& fmin,
                       const Numeric& fmax);

void linesElowToJoule(// WS Output:
                      ArrayOfLineRecord&);

void lines_per_tgCreateFromLines(// WS Output:
                                 ArrayOfArrayOfLineRecord&,
                                 // WS Input:
                                 const ArrayOfLineRecord&,
                                 const TagGroups&);

void lines_per_tgAddMirrorLines(// WS Output:
                                ArrayOfArrayOfLineRecord&);

void lines_per_tgCompact(// WS Output:
                         ArrayOfArrayOfLineRecord&,
                         // WS Input:
                         const ArrayOfLineshapeSpec&,
                         const Vector&);

void linesWriteAscii(// WS Input:
                     const ArrayOfLineRecord&,
                     // Control Parameters:
                     const String& filename);

void lines_per_tgWriteAscii(// WS Input:
                            const ArrayOfArrayOfLineRecord&,
                            // Control Parameters:
                            const String& filename);

void tgsDefine(// WS Output:
               TagGroups&,
               // Control Parameters:
               const ArrayOfString& tags);

void tgsDefineAllInScenario(// WS Output:
                            TagGroups&,
                            // Control Parameters:
                            const String& basename);

void lineshapeDefine(// WS Output:
                     ArrayOfLineshapeSpec&,
                     // WS Input:
                     const TagGroups&,
                     // Control Parameters:
                     const String& shape,
                     const String& normalizationfactor,
                     const Numeric& cutoff);

void lineshape_per_tgDefine(// WS Output:
                            ArrayOfLineshapeSpec&,
                            // WS Input:
                            const TagGroups&,
                            // Control Parameters:
                            const ArrayOfString& shape,
                            const ArrayOfString& normalizationfactor,
                            const Vector& cutoff);

void cont_descriptionInit(// WS Output:
                          ArrayOfString&,
                          ArrayOfString&,
                          ArrayOfVector&);

void cont_descriptionAppend(// WS Output:
                            ArrayOfString&,
                            ArrayOfString&,
                            ArrayOfVector&,
                            // Control Parameters:
                            const String& tagname,
                            const String& model,
                            const Vector& userparameters);

void raw_vmrsReadFromFiles(// WS Output:
                           ArrayOfMatrix&,
                           // WS Input:
                           const TagGroups&,
                           // Control Parameters:
                           const ArrayOfString& seltags,
                           const ArrayOfString& filenames,
                           const String& basename);

void raw_vmrsReadFromScenario(// WS Output:
                              ArrayOfMatrix&,
                              // WS Input:
                              const TagGroups&,
                              // Control Parameters:
                              const String& basename);

void AtmFromRaw(// WS Output:
                Vector&,
                Vector&,
                Matrix&,
                // WS Input:
                const TagGroups&,
                const Vector&,
                const Matrix&,
                const ArrayOfMatrix&);

void WaterVaporSaturationInClouds(// WS Output:
                                  Matrix&,
                                  Vector&,
                                  // WS Input:
                                  const Vector&,
                                  const TagGroups&);

void vmrsScale(// WS Output:
               Matrix&,
               // WS Input:
               const TagGroups&,
               // Control Parameters:
               const ArrayOfString& scaltgs,
               const Vector& scalfac);

void h2o_absSet(// WS Output:
                Vector&,
                // WS Input:
                const TagGroups&,
                const Matrix&);

void n2_absSet(// WS Output:
               Vector&,
               // WS Input:
               const TagGroups&,
               const Matrix&);

void hseSet(// WS Output:
            Vector&,
            // Control Parameters:
            const Numeric& pref,
            const Numeric& zref,
            const Numeric& g0,
            const Index& niter);

void hseSetFromLatitude(// WS Output:
                        Vector&,
                        // Control Parameters:
                        const Numeric& pref,
                        const Numeric& zref,
                        const Numeric& latitude,
                        const Index& niter);

void hseSetFromLatitudeIndex(// WS Output:
                             Vector&,
                             // WS Input:
                             const Vector&,
                             const Vector&,
                             // Control Parameters:
                             const Numeric& latitude,
                             const Index& index,
                             const Index& niter);

void hseFromBottom(// WS Output:
                   Vector&,
                   // WS Input:
                   const Vector&,
                   const Vector&,
                   // Control Parameters:
                   const Numeric& g0,
                   const Index& niter);

void hseOff(// WS Output:
            Vector&);

void hseCalc(// WS Output:
             Vector&,
             // WS Input:
             const Vector&,
             const Vector&,
             const Vector&,
             const Numeric&,
             const Vector&);

void absCalc(// WS Output:
             Matrix&,
             ArrayOfMatrix&,
             // WS Input:
             const TagGroups&,
             const Vector&,
             const Vector&,
             const Vector&,
             const Vector&,
             const Vector&,
             const Matrix&,
             const ArrayOfArrayOfLineRecord&,
             const ArrayOfLineshapeSpec&,
             const ArrayOfString&,
             const ArrayOfString&,
             const ArrayOfVector&);

void absCalcSaveMemory(// WS Output:
                       Matrix&,
                       // WS Input:
                       const TagGroups&,
                       const Vector&,
                       const Vector&,
                       const Vector&,
                       const Vector&,
                       const Vector&,
                       const Matrix&,
                       const ArrayOfArrayOfLineRecord&,
                       const ArrayOfLineshapeSpec&,
                       const ArrayOfString&,
                       const ArrayOfString&,
                       const ArrayOfVector&);

void absCalcFromXsec(// WS Output:
                     Matrix&,
                     ArrayOfMatrix&,
                     // WS Input:
                     const ArrayOfMatrix&,
                     const Matrix&);

void xsec_per_tgInit(// WS Output:
                     ArrayOfMatrix&,
                     // WS Input:
                     const TagGroups&,
                     const Vector&,
                     const Vector&);

void xsec_per_tgAddLines(// WS Output:
                         ArrayOfMatrix&,
                         // WS Input:
                         const TagGroups&,
                         const Vector&,
                         const Vector&,
                         const Vector&,
                         const Vector&,
                         const Matrix&,
                         const ArrayOfArrayOfLineRecord&,
                         const ArrayOfLineshapeSpec&);

void xsec_per_tgAddConts(// WS Output:
                         ArrayOfMatrix&,
                         // WS Input:
                         const TagGroups&,
                         const Vector&,
                         const Vector&,
                         const Vector&,
                         const Vector&,
                         const Vector&,
                         const Matrix&,
                         const ArrayOfString&,
                         const ArrayOfVector&,
                         const ArrayOfString&);

void abs_per_tgReduce(// WS Output:
                      ArrayOfMatrix&,
                      // WS Input:
                      const TagGroups&,
                      const TagGroups&);

void refrSet(// WS Output:
             Index&,
             Index&,
             String&,
             // Control Parameters:
             const Index& on,
             const String& model,
             const Index& lfac);

void refrOff(// WS Output:
             Index&,
             Index&,
             String&);

void refrCalc(// WS Output:
              Vector&,
              // WS Input:
              const Vector&,
              const Vector&,
              const Vector&,
              const Index&,
              const String&);

void zaFromZtan(// WS Generic Output:
                Vector&,
                // WS Generic Output Names:
                const String&,
                // WS Input:
                const Vector&,
                const Numeric&,
                const Vector&,
                const Vector&,
                const Index&,
                const Vector&,
                const Numeric&,
                const Numeric&);

void zaFromDeltat(// WS Generic Output:
                  Vector&,
                  // WS Generic Output Names:
                  const String&,
                  // WS Input:
                  const Numeric&,
                  const Vector&,
                  const Vector&,
                  const Numeric&,
                  const Index&,
                  const Index&,
                  const Vector&,
                  const Numeric&,
                  const Numeric&,
                  // Control Parameters:
                  const Numeric& delta_t,
                  const Vector& z_tan_lim);

void r_geoidStd(// WS Output:
                Numeric&);

void r_geoidWGS84(// WS Output:
                  Numeric&,
                  // Control Parameters:
                  const Numeric& latitude,
                  const Numeric& obsdirection);

void groundOff(// WS Output:
               Numeric&,
               Numeric&,
               Vector&,
               // WS Input:
               const Vector&);

void groundSet(// WS Output:
               Numeric&,
               Numeric&,
               Vector&,
               // WS Input:
               const Vector&,
               const Vector&,
               const Vector&,
               const Vector&,
               // Control Parameters:
               const Numeric& z,
               const Numeric& e);

void groundAtBottom(// WS Output:
                    Numeric&,
                    Numeric&,
                    Vector&,
                    // WS Input:
                    const Vector&,
                    const Vector&,
                    const Vector&,
                    // Control Parameters:
                    const Numeric& e);

void groundFlatSea(// WS Output:
                   Numeric&,
                   Numeric&,
                   Vector&,
                   // WS Input:
                   const Vector&,
                   const Vector&,
                   const Vector&,
                   const Vector&,
                   const Vector&,
                   const Numeric&,
                   const Numeric&,
                   const Index&,
                   const Vector&,
                   // Control Parameters:
                   const String& pol,
                   const Numeric& t_skin);

void emissionOn(// WS Output:
                Index&);

void emissionOff(// WS Output:
                 Index&);

void losCalc(// WS Output:
             Los&,
             Vector&,
             // WS Input:
             const Numeric&,
             const Vector&,
             const Numeric&,
             const Vector&,
             const Vector&,
             const Index&,
             const Index&,
             const Vector&,
             const Numeric&,
             const Numeric&);

void sourceCalc(// WS Output:
                ArrayOfMatrix&,
                // WS Input:
                const Index&,
                const Los&,
                const Vector&,
                const Vector&,
                const Vector&);

void transCalc(// WS Output:
               ArrayOfMatrix&,
               // WS Input:
               const Los&,
               const Vector&,
               const Matrix&);

void y_spaceStd(// WS Output:
                Vector&,
                // WS Input:
                const Vector&,
                // Control Parameters:
                const String& nr);

void yCalc(// WS Output:
           Vector&,
           // WS Input:
           const Index&,
           const Los&,
           const Vector&,
           const Vector&,
           const ArrayOfMatrix&,
           const ArrayOfMatrix&,
           const Vector&,
           const Numeric&);

void sourcetransyCalcSaveMemory(// WS Output:
                                Vector&,
                                // WS Input:
                                const Index&,
                                const Los&,
                                const Vector&,
                                const Vector&,
                                const Vector&,
                                const Matrix&,
                                const Vector&,
                                const Vector&,
                                const Numeric&,
                                // Control Parameters:
                                const Index& f_chunksize);

void CoolingRates(// WS Output:
                  Matrix&,
                  // WS Input:
                  const Numeric&,
                  const Vector&,
                  const Vector&,
                  const Vector&,
                  const Vector&,
                  const Matrix&,
                  const Vector&,
                  const Index&,
                  const Index&,
                  const Vector&,
                  const Numeric&,
                  const Numeric&,
                  const Vector&,
                  const Numeric&,
                  const Vector&,
                  // Control Parameters:
                  const Numeric& lstep_limit);

void yTB(// WS Output:
         Vector&,
         // WS Input:
         const Vector&,
         const Vector&);

void MatrixTB(// WS Generic Output:
              Matrix&,
              // WS Generic Output Names:
              const String&,
              // WS Input:
              const Vector&,
              const Vector&,
              // WS Generic Input:
              const Matrix&,
              // WS Generic Input Names:
              const String&);

void yTRJ(// WS Output:
          Vector&,
          // WS Input:
          const Vector&,
          const Vector&);

void MatrixTRJ(// WS Generic Output:
               Matrix&,
               // WS Generic Output Names:
               const String&,
               // WS Input:
               const Vector&,
               const Vector&,
               // WS Generic Input:
               const Matrix&,
               // WS Generic Input Names:
               const String&);

void wfs_tgsDefine(// WS Output:
                   TagGroups&,
                   // Control Parameters:
                   const ArrayOfString& wfs_tgs);

void wfss_tgsDefine(// WS Output:
                    TagGroups&,
                    // Control Parameters:
                    const ArrayOfString& wfss_tgs);

void absloswfsCalc(// WS Output:
                   ArrayOfMatrix&,
                   // WS Input:
                   const Index&,
                   const Los&,
                   const ArrayOfMatrix&,
                   const ArrayOfMatrix&,
                   const Vector&,
                   const Vector&,
                   const Vector&,
                   const Vector&,
                   const Numeric&);

void kSpecies(// WS Output:
              Matrix&,
              ArrayOfString&,
              Matrix&,
              // WS Input:
              const Los&,
              const ArrayOfMatrix&,
              const Vector&,
              const Vector&,
              const TagGroups&,
              const ArrayOfMatrix&,
              const Matrix&,
              const Vector&,
              // Control Parameters:
              const String& unit);

void kSpeciesSingle(// WS Output:
                    Matrix&,
                    ArrayOfString&,
                    Matrix&,
                    // WS Input:
                    const Los&,
                    const ArrayOfMatrix&,
                    const Vector&,
                    const Vector&,
                    const TagGroups&,
                    const ArrayOfMatrix&,
                    const Matrix&,
                    const Vector&,
                    // Control Parameters:
                    const String& tg,
                    const String& unit);

void kContAbs(// WS Output:
              Matrix&,
              ArrayOfString&,
              Matrix&,
              // WS Input:
              const Los&,
              const ArrayOfMatrix&,
              const Vector&,
              const Vector&,
              // Control Parameters:
              const Index& order,
              const Numeric& f_low,
              const Numeric& f_high,
              const String& l_unit);

void kTemp(// WS Output:
           Matrix&,
           ArrayOfString&,
           Matrix&,
           // WS Input:
           const TagGroups&,
           const Vector&,
           const Vector&,
           const Vector&,
           const Vector&,
           const Vector&,
           const Matrix&,
           const Matrix&,
           const ArrayOfArrayOfLineRecord&,
           const ArrayOfLineshapeSpec&,
           const Vector&,
           const Index&,
           const Vector&,
           const ArrayOfString&,
           const ArrayOfVector&,
           const ArrayOfString&,
           const Los&,
           const ArrayOfMatrix&,
           const ArrayOfMatrix&,
           const Numeric&,
           const Vector&,
           const Numeric&,
           const Vector&,
           const Index&,
           const Index&,
           const Vector&,
           const String&,
           const Numeric&,
           const Numeric&,
           const Vector&,
           const Numeric&,
           const Vector&,
           // Control Parameters:
           const Index& hse,
           const Index& fast);

void kSpectro(// WS Output:
              Matrix&,
              ArrayOfString&,
              Matrix&,
              Matrix&,
              // WS Input:
              const TagGroups&,
              const TagGroups&,
              const Vector&,
              const Vector&,
              const Vector&,
              const Vector&,
              const Vector&,
              const Matrix&,
              const ArrayOfArrayOfLineRecord&,
              const ArrayOfLineshapeSpec&,
              const Los&,
              const ArrayOfMatrix&,
              // Control Parameters:
              const Index& do_intens,
              const Index& do_position,
              const Index& do_agam,
              const Index& do_sgam,
              const Index& do_nair,
              const Index& do_nself,
              const Index& do_pSift);

void kFrequencyOffSet(// WS Output:
                      Matrix&,
                      ArrayOfString&,
                      Matrix&,
                      // WS Input:
                      const TagGroups&,
                      const Vector&,
                      const Vector&,
                      const Vector&,
                      const Vector&,
                      const Vector&,
                      const Matrix&,
                      const ArrayOfArrayOfLineRecord&,
                      const ArrayOfLineshapeSpec&,
                      const Vector&,
                      const Index&,
                      const ArrayOfString&,
                      const ArrayOfVector&,
                      const ArrayOfString&,
                      const Los&,
                      const Numeric&,
                      const Vector&,
                      const Vector&,
                      // Control Parameters:
                      const Numeric& delta,
                      const String& f_unit);

void kPointingOffSet(// WS Output:
                     Matrix&,
                     ArrayOfString&,
                     Matrix&,
                     // WS Input:
                     const Numeric&,
                     const Vector&,
                     const Numeric&,
                     const Vector&,
                     const Vector&,
                     const Vector&,
                     const Vector&,
                     const Index&,
                     const Index&,
                     const Vector&,
                     const Numeric&,
                     const Numeric&,
                     const Matrix&,
                     const Index&,
                     const Vector&,
                     const Vector&,
                     const Numeric&,
                     const Vector&,
                     // Control Parameters:
                     const Numeric& delta);

void kEground(// WS Output:
              Matrix&,
              ArrayOfString&,
              Matrix&,
              // WS Input:
              const Vector&,
              const Vector&,
              const Index&,
              const Vector&,
              const Vector&,
              const Numeric&,
              const Los&,
              const ArrayOfMatrix&,
              const ArrayOfMatrix&,
              // Control Parameters:
              const Index& single_e);

void kCalibration(// WS Output:
                  Matrix&,
                  ArrayOfString&,
                  Matrix&,
                  // WS Input:
                  const Vector&,
                  const Vector&,
                  // WS Generic Input:
                  const Vector&,
                  // WS Generic Input Names:
                  const String&);

void kManual(// WS Output:
             Matrix&,
             ArrayOfString&,
             Matrix&,
             // WS Input:
             const Vector&,
             const Vector&,
             // Control Parameters:
             const String& name,
             const Numeric& delta,
             const Numeric& grid,
             const Numeric& apriori);

void kxInit(// WS Output:
            Matrix&,
            ArrayOfString&,
            ArrayOfIndex&,
            Matrix&);

void kbInit(// WS Output:
            Matrix&,
            ArrayOfString&,
            ArrayOfIndex&,
            Matrix&);

void kxAppend(// WS Output:
              Matrix&,
              ArrayOfString&,
              ArrayOfIndex&,
              Matrix&,
              // WS Input:
              const Matrix&,
              const ArrayOfString&,
              const Matrix&);

void kbAppend(// WS Output:
              Matrix&,
              ArrayOfString&,
              ArrayOfIndex&,
              Matrix&,
              // WS Input:
              const Matrix&,
              const ArrayOfString&,
              const Matrix&);

void kxAllocate(// WS Output:
                Matrix&,
                ArrayOfString&,
                ArrayOfIndex&,
                Matrix&,
                // WS Generic Input:
                const Vector&,
                // WS Generic Input Names:
                const String&,
                // Control Parameters:
                const Index& ni,
                const Index& nx);

void kbAllocate(// WS Output:
                Matrix&,
                ArrayOfString&,
                ArrayOfIndex&,
                Matrix&,
                // WS Generic Input:
                const Vector&,
                // WS Generic Input Names:
                const String&,
                // Control Parameters:
                const Index& ni,
                const Index& nb);

void kxPutInK(// WS Output:
              Matrix&,
              ArrayOfString&,
              ArrayOfIndex&,
              Matrix&,
              // WS Input:
              const Matrix&,
              const ArrayOfString&,
              const Matrix&);

void kbPutInK(// WS Output:
              Matrix&,
              ArrayOfString&,
              ArrayOfIndex&,
              Matrix&,
              // WS Input:
              const Matrix&,
              const ArrayOfString&,
              const Matrix&);

void ybatchCalc(// WS Output:
                Matrix&,
                // WS Input:
                const Vector&,
                const Vector&,
                const Vector&,
                const Vector&,
                const Vector&,
                const Matrix&,
                const ArrayOfArrayOfLineRecord&,
                const ArrayOfLineshapeSpec&,
                const Vector&,
                const Numeric&,
                const Vector&,
                const Numeric&,
                const Index&,
                const Index&,
                const Vector&,
                const Numeric&,
                const Numeric&,
                const Index&,
                const Vector&,
                const Vector&,
                const Numeric&,
                const String&,
                const TagGroups&,
                const ArrayOfString&,
                const ArrayOfVector&,
                const ArrayOfString&,
                // Control Parameters:
                const Index& ncalc,
                const Index& do_t,
                const String& t_file,
                const Index& do_z,
                const String& z_file,
                const ArrayOfString& do_tags,
                const ArrayOfString& tag_files,
                const Index& do_f,
                const String& f_file,
                const Index& do_za,
                const String& za_file);

void ybatchFromRadiosonde(// WS Output:
                          Matrix&,
                          ArrayOfMatrix&,
                          ArrayOfMatrix&,
                          // WS Input:
                          const ArrayOfMatrix&,
                          const Vector&,
                          const ArrayOfArrayOfLineRecord&,
                          const ArrayOfLineshapeSpec&,
                          const Numeric&,
                          const Vector&,
                          const Numeric&,
                          const Index&,
                          const String&,
                          const Index&,
                          const Numeric&,
                          const Index&,
                          const Vector&,
                          const Vector&,
                          const TagGroups&,
                          const ArrayOfString&,
                          const ArrayOfString&,
                          const ArrayOfVector&,
                          // Control Parameters:
                          const Index& finegrid,
                          const Index& interp_rh,
                          const Index& za_per_profile,
                          const Index& e_ground_per_profile,
                          const Index& calc_abs,
                          const Index& calc_jac);

void ybatchFromRadiosondeGlobal(// WS Output:
                                Matrix&,
                                // WS Input:
                                const ArrayOfMatrix&,
                                const Vector&,
                                const ArrayOfArrayOfLineRecord&,
                                const ArrayOfLineshapeSpec&,
                                const Numeric&,
                                const Vector&,
                                const Numeric&,
                                const Index&,
                                const String&,
                                const Index&,
                                const Numeric&,
                                const Index&,
                                const Vector&,
                                const Vector&,
                                const TagGroups&,
                                const ArrayOfString&,
                                const ArrayOfString&,
                                const ArrayOfVector&);

void MethodListDefine(// WS Generic Output:
                      ArrayOfIndex&,
                      // WS Generic Output Names:
                      const String&,
                      // Control Parameters:
                      const ArrayOfString& methods);

// Get-away function declarations:

void Echo_g(WorkSpace& ws, const MRecord& mr);
void Exit_g(WorkSpace& ws, const MRecord& mr);
void Test_g(WorkSpace& ws, const MRecord& mr);
void IndexSet_g(WorkSpace& ws, const MRecord& mr);
void IndexWriteAscii_g(WorkSpace& ws, const MRecord& mr);
void IndexReadAscii_g(WorkSpace& ws, const MRecord& mr);
void IndexWriteBinary_g(WorkSpace& ws, const MRecord& mr);
void IndexReadBinary_g(WorkSpace& ws, const MRecord& mr);
void NumericSet_g(WorkSpace& ws, const MRecord& mr);
void NumericCopyFirstOfVector_g(WorkSpace& ws, const MRecord& mr);
void NumericCopyLastOfVector_g(WorkSpace& ws, const MRecord& mr);
void NumericWriteAscii_g(WorkSpace& ws, const MRecord& mr);
void NumericReadAscii_g(WorkSpace& ws, const MRecord& mr);
void NumericWriteBinary_g(WorkSpace& ws, const MRecord& mr);
void NumericReadBinary_g(WorkSpace& ws, const MRecord& mr);
void VectorCopy_g(WorkSpace& ws, const MRecord& mr);
void VectorCopyFromMatrix_g(WorkSpace& ws, const MRecord& mr);
void VectorSet_g(WorkSpace& ws, const MRecord& mr);
void VectorSetLengthFromVector_g(WorkSpace& ws, const MRecord& mr);
void VectorLinSpace_g(WorkSpace& ws, const MRecord& mr);
void VectorNLinSpace_g(WorkSpace& ws, const MRecord& mr);
void VectorNLogSpace_g(WorkSpace& ws, const MRecord& mr);
void VectorPressuresForLinAltitudes_g(WorkSpace& ws, const MRecord& mr);
void VectorFlip_g(WorkSpace& ws, const MRecord& mr);
void VectorMatrixMultiply_g(WorkSpace& ws, const MRecord& mr);
void VectorWriteAscii_g(WorkSpace& ws, const MRecord& mr);
void VectorReadAscii_g(WorkSpace& ws, const MRecord& mr);
void VectorWriteBinary_g(WorkSpace& ws, const MRecord& mr);
void VectorReadBinary_g(WorkSpace& ws, const MRecord& mr);
void VectorPlanck_g(WorkSpace& ws, const MRecord& mr);
void VectorCalcLog10_g(WorkSpace& ws, const MRecord& mr);
void VectorAdd_g(WorkSpace& ws, const MRecord& mr);
void VectorScale_g(WorkSpace& ws, const MRecord& mr);
void MatrixSet_g(WorkSpace& ws, const MRecord& mr);
void MatrixCopy_g(WorkSpace& ws, const MRecord& mr);
void MatrixFillWithVector_g(WorkSpace& ws, const MRecord& mr);
void MatrixMatrixMultiply_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfMatrixMatrixMultiply_g(WorkSpace& ws, const MRecord& mr);
void MatrixMatrixAdd_g(WorkSpace& ws, const MRecord& mr);
void MatrixWriteAscii_g(WorkSpace& ws, const MRecord& mr);
void MatrixReadAscii_g(WorkSpace& ws, const MRecord& mr);
void MatrixWriteBinary_g(WorkSpace& ws, const MRecord& mr);
void MatrixReadBinary_g(WorkSpace& ws, const MRecord& mr);
void MatrixScale_g(WorkSpace& ws, const MRecord& mr);
void MatrixDiagonal_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfIndexWriteAscii_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfIndexReadAscii_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfIndexWriteBinary_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfIndexReadBinary_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfVectorWriteAscii_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfVectorReadAscii_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfVectorWriteBinary_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfVectorReadBinary_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfMatrixWriteAscii_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfMatrixReadAscii_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfMatrixWriteBinary_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfMatrixReadBinary_g(WorkSpace& ws, const MRecord& mr);
void StringSet_g(WorkSpace& ws, const MRecord& mr);
void StringWriteAscii_g(WorkSpace& ws, const MRecord& mr);
void StringReadAscii_g(WorkSpace& ws, const MRecord& mr);
void StringWriteBinary_g(WorkSpace& ws, const MRecord& mr);
void StringReadBinary_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfStringSet_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfStringWriteAscii_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfStringReadAscii_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfStringWriteBinary_g(WorkSpace& ws, const MRecord& mr);
void ArrayOfStringReadBinary_g(WorkSpace& ws, const MRecord& mr);
void TagGroupsSpeciesWriteAscii_g(WorkSpace& ws, const MRecord& mr);
void LosWriteBinary_g(WorkSpace& ws, const MRecord& mr);
void LosReadBinary_g(WorkSpace& ws, const MRecord& mr);
void lines_per_tgSetEmpty_g(WorkSpace& ws, const MRecord& mr);
void lines_per_tgReadFromCatalogues_g(WorkSpace& ws, const MRecord& mr);
void linesReadFromHitran_g(WorkSpace& ws, const MRecord& mr);
void linesReadFromHitran2004_g(WorkSpace& ws, const MRecord& mr);
void linesReadFromMytran2_g(WorkSpace& ws, const MRecord& mr);
void linesReadFromJpl_g(WorkSpace& ws, const MRecord& mr);
void linesReadFromArts_g(WorkSpace& ws, const MRecord& mr);
void linesElowToJoule_g(WorkSpace& ws, const MRecord& mr);
void lines_per_tgCreateFromLines_g(WorkSpace& ws, const MRecord& mr);
void lines_per_tgAddMirrorLines_g(WorkSpace& ws, const MRecord& mr);
void lines_per_tgCompact_g(WorkSpace& ws, const MRecord& mr);
void linesWriteAscii_g(WorkSpace& ws, const MRecord& mr);
void lines_per_tgWriteAscii_g(WorkSpace& ws, const MRecord& mr);
void tgsDefine_g(WorkSpace& ws, const MRecord& mr);
void tgsDefineAllInScenario_g(WorkSpace& ws, const MRecord& mr);
void lineshapeDefine_g(WorkSpace& ws, const MRecord& mr);
void lineshape_per_tgDefine_g(WorkSpace& ws, const MRecord& mr);
void cont_descriptionInit_g(WorkSpace& ws, const MRecord& mr);
void cont_descriptionAppend_g(WorkSpace& ws, const MRecord& mr);
void raw_vmrsReadFromFiles_g(WorkSpace& ws, const MRecord& mr);
void raw_vmrsReadFromScenario_g(WorkSpace& ws, const MRecord& mr);
void AtmFromRaw_g(WorkSpace& ws, const MRecord& mr);
void WaterVaporSaturationInClouds_g(WorkSpace& ws, const MRecord& mr);
void vmrsScale_g(WorkSpace& ws, const MRecord& mr);
void h2o_absSet_g(WorkSpace& ws, const MRecord& mr);
void n2_absSet_g(WorkSpace& ws, const MRecord& mr);
void hseSet_g(WorkSpace& ws, const MRecord& mr);
void hseSetFromLatitude_g(WorkSpace& ws, const MRecord& mr);
void hseSetFromLatitudeIndex_g(WorkSpace& ws, const MRecord& mr);
void hseFromBottom_g(WorkSpace& ws, const MRecord& mr);
void hseOff_g(WorkSpace& ws, const MRecord& mr);
void hseCalc_g(WorkSpace& ws, const MRecord& mr);
void absCalc_g(WorkSpace& ws, const MRecord& mr);
void absCalcSaveMemory_g(WorkSpace& ws, const MRecord& mr);
void absCalcFromXsec_g(WorkSpace& ws, const MRecord& mr);
void xsec_per_tgInit_g(WorkSpace& ws, const MRecord& mr);
void xsec_per_tgAddLines_g(WorkSpace& ws, const MRecord& mr);
void xsec_per_tgAddConts_g(WorkSpace& ws, const MRecord& mr);
void abs_per_tgReduce_g(WorkSpace& ws, const MRecord& mr);
void refrSet_g(WorkSpace& ws, const MRecord& mr);
void refrOff_g(WorkSpace& ws, const MRecord& mr);
void refrCalc_g(WorkSpace& ws, const MRecord& mr);
void zaFromZtan_g(WorkSpace& ws, const MRecord& mr);
void zaFromDeltat_g(WorkSpace& ws, const MRecord& mr);
void r_geoidStd_g(WorkSpace& ws, const MRecord& mr);
void r_geoidWGS84_g(WorkSpace& ws, const MRecord& mr);
void groundOff_g(WorkSpace& ws, const MRecord& mr);
void groundSet_g(WorkSpace& ws, const MRecord& mr);
void groundAtBottom_g(WorkSpace& ws, const MRecord& mr);
void groundFlatSea_g(WorkSpace& ws, const MRecord& mr);
void emissionOn_g(WorkSpace& ws, const MRecord& mr);
void emissionOff_g(WorkSpace& ws, const MRecord& mr);
void losCalc_g(WorkSpace& ws, const MRecord& mr);
void sourceCalc_g(WorkSpace& ws, const MRecord& mr);
void transCalc_g(WorkSpace& ws, const MRecord& mr);
void y_spaceStd_g(WorkSpace& ws, const MRecord& mr);
void yCalc_g(WorkSpace& ws, const MRecord& mr);
void sourcetransyCalcSaveMemory_g(WorkSpace& ws, const MRecord& mr);
void CoolingRates_g(WorkSpace& ws, const MRecord& mr);
void yTB_g(WorkSpace& ws, const MRecord& mr);
void MatrixTB_g(WorkSpace& ws, const MRecord& mr);
void yTRJ_g(WorkSpace& ws, const MRecord& mr);
void MatrixTRJ_g(WorkSpace& ws, const MRecord& mr);
void wfs_tgsDefine_g(WorkSpace& ws, const MRecord& mr);
void wfss_tgsDefine_g(WorkSpace& ws, const MRecord& mr);
void absloswfsCalc_g(WorkSpace& ws, const MRecord& mr);
void kSpecies_g(WorkSpace& ws, const MRecord& mr);
void kSpeciesSingle_g(WorkSpace& ws, const MRecord& mr);
void kContAbs_g(WorkSpace& ws, const MRecord& mr);
void kTemp_g(WorkSpace& ws, const MRecord& mr);
void kSpectro_g(WorkSpace& ws, const MRecord& mr);
void kFrequencyOffSet_g(WorkSpace& ws, const MRecord& mr);
void kPointingOffSet_g(WorkSpace& ws, const MRecord& mr);
void kEground_g(WorkSpace& ws, const MRecord& mr);
void kCalibration_g(WorkSpace& ws, const MRecord& mr);
void kManual_g(WorkSpace& ws, const MRecord& mr);
void kxInit_g(WorkSpace& ws, const MRecord& mr);
void kbInit_g(WorkSpace& ws, const MRecord& mr);
void kxAppend_g(WorkSpace& ws, const MRecord& mr);
void kbAppend_g(WorkSpace& ws, const MRecord& mr);
void kxAllocate_g(WorkSpace& ws, const MRecord& mr);
void kbAllocate_g(WorkSpace& ws, const MRecord& mr);
void kxPutInK_g(WorkSpace& ws, const MRecord& mr);
void kbPutInK_g(WorkSpace& ws, const MRecord& mr);
void ybatchCalc_g(WorkSpace& ws, const MRecord& mr);
void ybatchFromRadiosonde_g(WorkSpace& ws, const MRecord& mr);
void ybatchFromRadiosondeGlobal_g(WorkSpace& ws, const MRecord& mr);
void MethodListDefine_g(WorkSpace& ws, const MRecord& mr);


#endif  // auto_md_h

---