auto_md.cc

Go to the documentation of this file.

// This file was generated automatically by make_auto_md_cc.cc.
// DO NOT EDIT !
// Generated: Oct  8 2020, 14:36:24
 
#include "arts.h"
#include "make_array.h"
#include "auto_md.h"
#include "auto_wsv_groups.h"
#include "wsv_aux.h"
 
// The workspace variable pointers:
extern const Array<WsvP*> wsv_pointers;
 
// Other wsv data:
extern const Array<WsvRecord> wsv_data;
 
void Echo_g(WorkSpace&, const MRecord& mr)
{
  Echo(mr.Values()[0],
       mr.Values()[1]);
}
 
void Exit_g(WorkSpace&, const MRecord&)
{
  Exit();
}
 
void Test_g(WorkSpace&, const MRecord&)
{
  Test();
}
 
void IndexSet_g(WorkSpace&, const MRecord& mr)
{
  Index *GO0 = *wsv_pointers[mr.Output()[0]];
  IndexSet(*GO0,
           wsv_data[mr.Output()[0]].Name(),
           mr.Values()[0]);
}
 
void IndexWriteAscii_g(WorkSpace&, const MRecord& mr)
{
  Index *GI0 = *wsv_pointers[mr.Input()[0]];
  IndexWriteAscii(*GI0,
                  wsv_data[mr.Input()[0]].Name(),
                  mr.Values()[0]);
}
 
void IndexReadAscii_g(WorkSpace&, const MRecord& mr)
{
  Index *GO0 = *wsv_pointers[mr.Output()[0]];
  IndexReadAscii(*GO0,
                 wsv_data[mr.Output()[0]].Name(),
                 mr.Values()[0]);
}
 
void IndexWriteBinary_g(WorkSpace&, const MRecord& mr)
{
  Index *GI0 = *wsv_pointers[mr.Input()[0]];
  IndexWriteBinary(*GI0,
                   wsv_data[mr.Input()[0]].Name(),
                   mr.Values()[0]);
}
 
void IndexReadBinary_g(WorkSpace&, const MRecord& mr)
{
  Index *GO0 = *wsv_pointers[mr.Output()[0]];
  IndexReadBinary(*GO0,
                  wsv_data[mr.Output()[0]].Name(),
                  mr.Values()[0]);
}
 
void NumericSet_g(WorkSpace&, const MRecord& mr)
{
  Numeric *GO0 = *wsv_pointers[mr.Output()[0]];
  NumericSet(*GO0,
             wsv_data[mr.Output()[0]].Name(),
             mr.Values()[0]);
}
 
void NumericCopyFirstOfVector_g(WorkSpace&, const MRecord& mr)
{
  Numeric *GO0 = *wsv_pointers[mr.Output()[0]];
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  NumericCopyFirstOfVector(*GO0,
                           wsv_data[mr.Output()[0]].Name(),
                           *GI0,
                           wsv_data[mr.Input()[0]].Name());
}
 
void NumericCopyLastOfVector_g(WorkSpace&, const MRecord& mr)
{
  Numeric *GO0 = *wsv_pointers[mr.Output()[0]];
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  NumericCopyLastOfVector(*GO0,
                          wsv_data[mr.Output()[0]].Name(),
                          *GI0,
                          wsv_data[mr.Input()[0]].Name());
}
 
void NumericWriteAscii_g(WorkSpace&, const MRecord& mr)
{
  Numeric *GI0 = *wsv_pointers[mr.Input()[0]];
  NumericWriteAscii(*GI0,
                    wsv_data[mr.Input()[0]].Name(),
                    mr.Values()[0]);
}
 
void NumericReadAscii_g(WorkSpace&, const MRecord& mr)
{
  Numeric *GO0 = *wsv_pointers[mr.Output()[0]];
  NumericReadAscii(*GO0,
                   wsv_data[mr.Output()[0]].Name(),
                   mr.Values()[0]);
}
 
void NumericWriteBinary_g(WorkSpace&, const MRecord& mr)
{
  Numeric *GI0 = *wsv_pointers[mr.Input()[0]];
  NumericWriteBinary(*GI0,
                     wsv_data[mr.Input()[0]].Name(),
                     mr.Values()[0]);
}
 
void NumericReadBinary_g(WorkSpace&, const MRecord& mr)
{
  Numeric *GO0 = *wsv_pointers[mr.Output()[0]];
  NumericReadBinary(*GO0,
                    wsv_data[mr.Output()[0]].Name(),
                    mr.Values()[0]);
}
 
void VectorCopy_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  VectorCopy(*GO0,
             wsv_data[mr.Output()[0]].Name(),
             *GI0,
             wsv_data[mr.Input()[0]].Name());
}
 
void VectorCopyFromMatrix_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
  VectorCopyFromMatrix(*GO0,
                       wsv_data[mr.Output()[0]].Name(),
                       *GI0,
                       wsv_data[mr.Input()[0]].Name(),
                       mr.Values()[0],
                       mr.Values()[1]);
}
 
void VectorSet_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  VectorSet(*GO0,
            wsv_data[mr.Output()[0]].Name(),
            mr.Values()[0],
            mr.Values()[1]);
}
 
void VectorSetLengthFromVector_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  VectorSetLengthFromVector(*GO0,
                            wsv_data[mr.Output()[0]].Name(),
                            *GI0,
                            wsv_data[mr.Input()[0]].Name(),
                            mr.Values()[0]);
}
 
void VectorLinSpace_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  VectorLinSpace(*GO0,
                 wsv_data[mr.Output()[0]].Name(),
                 mr.Values()[0],
                 mr.Values()[1],
                 mr.Values()[2]);
}
 
void VectorNLinSpace_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  VectorNLinSpace(*GO0,
                  wsv_data[mr.Output()[0]].Name(),
                  mr.Values()[0],
                  mr.Values()[1],
                  mr.Values()[2]);
}
 
void VectorNLogSpace_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  VectorNLogSpace(*GO0,
                  wsv_data[mr.Output()[0]].Name(),
                  mr.Values()[0],
                  mr.Values()[1],
                  mr.Values()[2]);
}
 
void VectorPressuresForLinAltitudes_g(WorkSpace& ws, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  VectorPressuresForLinAltitudes(*GO0,
                                 wsv_data[mr.Output()[0]].Name(),
                                 ws.p_abs,
                                 ws.z_abs,
                                 mr.Values()[0],
                                 mr.Values()[1],
                                 mr.Values()[2]);
}
 
void VectorFlip_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  VectorFlip(*GO0,
             wsv_data[mr.Output()[0]].Name(),
             *GI0,
             wsv_data[mr.Input()[0]].Name());
}
 
void VectorMatrixMultiply_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
  Vector *GI1 = *wsv_pointers[mr.Input()[1]];
  VectorMatrixMultiply(*GO0,
                       wsv_data[mr.Output()[0]].Name(),
                       *GI0,
                       *GI1,
                       wsv_data[mr.Input()[0]].Name(),
                       wsv_data[mr.Input()[1]].Name());
}
 
void VectorWriteAscii_g(WorkSpace&, const MRecord& mr)
{
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  VectorWriteAscii(*GI0,
                   wsv_data[mr.Input()[0]].Name(),
                   mr.Values()[0]);
}
 
void VectorReadAscii_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  VectorReadAscii(*GO0,
                  wsv_data[mr.Output()[0]].Name(),
                  mr.Values()[0]);
}
 
void VectorWriteBinary_g(WorkSpace&, const MRecord& mr)
{
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  VectorWriteBinary(*GI0,
                    wsv_data[mr.Input()[0]].Name(),
                    mr.Values()[0]);
}
 
void VectorReadBinary_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  VectorReadBinary(*GO0,
                   wsv_data[mr.Output()[0]].Name(),
                   mr.Values()[0]);
}
 
void VectorPlanck_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  VectorPlanck(*GO0,
               wsv_data[mr.Output()[0]].Name(),
               *GI0,
               wsv_data[mr.Input()[0]].Name(),
               mr.Values()[0]);
}
 
void VectorCalcLog10_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  VectorCalcLog10(*GO0,
                  wsv_data[mr.Output()[0]].Name(),
                  *GI0,
                  wsv_data[mr.Input()[0]].Name());
}
 
void VectorAdd_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  VectorAdd(*GO0,
            wsv_data[mr.Output()[0]].Name(),
            *GI0,
            wsv_data[mr.Input()[0]].Name(),
            mr.Values()[0]);
}
 
void VectorScale_g(WorkSpace&, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  VectorScale(*GO0,
              wsv_data[mr.Output()[0]].Name(),
              *GI0,
              wsv_data[mr.Input()[0]].Name(),
              mr.Values()[0]);
}
 
void MatrixSet_g(WorkSpace&, const MRecord& mr)
{
  Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
  MatrixSet(*GO0,
            wsv_data[mr.Output()[0]].Name(),
            mr.Values()[0],
            mr.Values()[1],
            mr.Values()[2]);
}
 
void MatrixCopy_g(WorkSpace&, const MRecord& mr)
{
  Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
  Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
  MatrixCopy(*GO0,
             wsv_data[mr.Output()[0]].Name(),
             *GI0,
             wsv_data[mr.Input()[0]].Name());
}
 
void MatrixFillWithVector_g(WorkSpace&, const MRecord& mr)
{
  Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  MatrixFillWithVector(*GO0,
                       wsv_data[mr.Output()[0]].Name(),
                       *GI0,
                       wsv_data[mr.Input()[0]].Name(),
                       mr.Values()[0]);
}
 
void MatrixMatrixMultiply_g(WorkSpace&, const MRecord& mr)
{
  Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
  Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
  Matrix *GI1 = *wsv_pointers[mr.Input()[1]];
  MatrixMatrixMultiply(*GO0,
                       wsv_data[mr.Output()[0]].Name(),
                       *GI0,
                       *GI1,
                       wsv_data[mr.Input()[0]].Name(),
                       wsv_data[mr.Input()[1]].Name());
}
 
void ArrayOfMatrixMatrixMultiply_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfMatrix *GO0 = *wsv_pointers[mr.Output()[0]];
  Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
  ArrayOfMatrix *GI1 = *wsv_pointers[mr.Input()[1]];
  ArrayOfMatrixMatrixMultiply(*GO0,
                              wsv_data[mr.Output()[0]].Name(),
                              *GI0,
                              *GI1,
                              wsv_data[mr.Input()[0]].Name(),
                              wsv_data[mr.Input()[1]].Name());
}
 
void MatrixMatrixAdd_g(WorkSpace&, const MRecord& mr)
{
  Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
  Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
  Matrix *GI1 = *wsv_pointers[mr.Input()[1]];
  MatrixMatrixAdd(*GO0,
                  wsv_data[mr.Output()[0]].Name(),
                  *GI0,
                  *GI1,
                  wsv_data[mr.Input()[0]].Name(),
                  wsv_data[mr.Input()[1]].Name());
}
 
void MatrixWriteAscii_g(WorkSpace&, const MRecord& mr)
{
  Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
  MatrixWriteAscii(*GI0,
                   wsv_data[mr.Input()[0]].Name(),
                   mr.Values()[0]);
}
 
void MatrixReadAscii_g(WorkSpace&, const MRecord& mr)
{
  Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
  MatrixReadAscii(*GO0,
                  wsv_data[mr.Output()[0]].Name(),
                  mr.Values()[0]);
}
 
void MatrixWriteBinary_g(WorkSpace&, const MRecord& mr)
{
  Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
  MatrixWriteBinary(*GI0,
                    wsv_data[mr.Input()[0]].Name(),
                    mr.Values()[0]);
}
 
void MatrixReadBinary_g(WorkSpace&, const MRecord& mr)
{
  Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
  MatrixReadBinary(*GO0,
                   wsv_data[mr.Output()[0]].Name(),
                   mr.Values()[0]);
}
 
void MatrixScale_g(WorkSpace&, const MRecord& mr)
{
  Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
  Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
  MatrixScale(*GO0,
              wsv_data[mr.Output()[0]].Name(),
              *GI0,
              wsv_data[mr.Input()[0]].Name(),
              mr.Values()[0]);
}
 
void MatrixDiagonal_g(WorkSpace&, const MRecord& mr)
{
  Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
  MatrixDiagonal(*GO0,
                 wsv_data[mr.Output()[0]].Name(),
                 mr.Values()[0],
                 mr.Values()[1]);
}
 
void ArrayOfIndexWriteAscii_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfIndex *GI0 = *wsv_pointers[mr.Input()[0]];
  ArrayOfIndexWriteAscii(*GI0,
                         wsv_data[mr.Input()[0]].Name(),
                         mr.Values()[0]);
}
 
void ArrayOfIndexReadAscii_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfIndex *GO0 = *wsv_pointers[mr.Output()[0]];
  ArrayOfIndexReadAscii(*GO0,
                        wsv_data[mr.Output()[0]].Name(),
                        mr.Values()[0]);
}
 
void ArrayOfIndexWriteBinary_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfIndex *GI0 = *wsv_pointers[mr.Input()[0]];
  ArrayOfIndexWriteBinary(*GI0,
                          wsv_data[mr.Input()[0]].Name(),
                          mr.Values()[0]);
}
 
void ArrayOfIndexReadBinary_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfIndex *GO0 = *wsv_pointers[mr.Output()[0]];
  ArrayOfIndexReadBinary(*GO0,
                         wsv_data[mr.Output()[0]].Name(),
                         mr.Values()[0]);
}
 
void ArrayOfVectorWriteAscii_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfVector *GI0 = *wsv_pointers[mr.Input()[0]];
  ArrayOfVectorWriteAscii(*GI0,
                          wsv_data[mr.Input()[0]].Name(),
                          mr.Values()[0]);
}
 
void ArrayOfVectorReadAscii_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfVector *GO0 = *wsv_pointers[mr.Output()[0]];
  ArrayOfVectorReadAscii(*GO0,
                         wsv_data[mr.Output()[0]].Name(),
                         mr.Values()[0]);
}
 
void ArrayOfVectorWriteBinary_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfVector *GI0 = *wsv_pointers[mr.Input()[0]];
  ArrayOfVectorWriteBinary(*GI0,
                           wsv_data[mr.Input()[0]].Name(),
                           mr.Values()[0]);
}
 
void ArrayOfVectorReadBinary_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfVector *GO0 = *wsv_pointers[mr.Output()[0]];
  ArrayOfVectorReadBinary(*GO0,
                          wsv_data[mr.Output()[0]].Name(),
                          mr.Values()[0]);
}
 
void ArrayOfMatrixWriteAscii_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfMatrix *GI0 = *wsv_pointers[mr.Input()[0]];
  ArrayOfMatrixWriteAscii(*GI0,
                          wsv_data[mr.Input()[0]].Name(),
                          mr.Values()[0]);
}
 
void ArrayOfMatrixReadAscii_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfMatrix *GO0 = *wsv_pointers[mr.Output()[0]];
  ArrayOfMatrixReadAscii(*GO0,
                         wsv_data[mr.Output()[0]].Name(),
                         mr.Values()[0]);
}
 
void ArrayOfMatrixWriteBinary_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfMatrix *GI0 = *wsv_pointers[mr.Input()[0]];
  ArrayOfMatrixWriteBinary(*GI0,
                           wsv_data[mr.Input()[0]].Name(),
                           mr.Values()[0]);
}
 
void ArrayOfMatrixReadBinary_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfMatrix *GO0 = *wsv_pointers[mr.Output()[0]];
  ArrayOfMatrixReadBinary(*GO0,
                          wsv_data[mr.Output()[0]].Name(),
                          mr.Values()[0]);
}
 
void StringSet_g(WorkSpace&, const MRecord& mr)
{
  String *GO0 = *wsv_pointers[mr.Output()[0]];
  StringSet(*GO0,
            wsv_data[mr.Output()[0]].Name(),
            mr.Values()[0]);
}
 
void StringWriteAscii_g(WorkSpace&, const MRecord& mr)
{
  String *GI0 = *wsv_pointers[mr.Input()[0]];
  StringWriteAscii(*GI0,
                   wsv_data[mr.Input()[0]].Name(),
                   mr.Values()[0]);
}
 
void StringReadAscii_g(WorkSpace&, const MRecord& mr)
{
  String *GO0 = *wsv_pointers[mr.Output()[0]];
  StringReadAscii(*GO0,
                  wsv_data[mr.Output()[0]].Name(),
                  mr.Values()[0]);
}
 
void StringWriteBinary_g(WorkSpace&, const MRecord& mr)
{
  String *GI0 = *wsv_pointers[mr.Input()[0]];
  StringWriteBinary(*GI0,
                    wsv_data[mr.Input()[0]].Name(),
                    mr.Values()[0]);
}
 
void StringReadBinary_g(WorkSpace&, const MRecord& mr)
{
  String *GO0 = *wsv_pointers[mr.Output()[0]];
  StringReadBinary(*GO0,
                   wsv_data[mr.Output()[0]].Name(),
                   mr.Values()[0]);
}
 
void ArrayOfStringSet_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfString *GO0 = *wsv_pointers[mr.Output()[0]];
  ArrayOfStringSet(*GO0,
                   wsv_data[mr.Output()[0]].Name(),
                   mr.Values()[0]);
}
 
void ArrayOfStringWriteAscii_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfString *GI0 = *wsv_pointers[mr.Input()[0]];
  ArrayOfStringWriteAscii(*GI0,
                          wsv_data[mr.Input()[0]].Name(),
                          mr.Values()[0]);
}
 
void ArrayOfStringReadAscii_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfString *GO0 = *wsv_pointers[mr.Output()[0]];
  ArrayOfStringReadAscii(*GO0,
                         wsv_data[mr.Output()[0]].Name(),
                         mr.Values()[0]);
}
 
void ArrayOfStringWriteBinary_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfString *GI0 = *wsv_pointers[mr.Input()[0]];
  ArrayOfStringWriteBinary(*GI0,
                           wsv_data[mr.Input()[0]].Name(),
                           mr.Values()[0]);
}
 
void ArrayOfStringReadBinary_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfString *GO0 = *wsv_pointers[mr.Output()[0]];
  ArrayOfStringReadBinary(*GO0,
                          wsv_data[mr.Output()[0]].Name(),
                          mr.Values()[0]);
}
 
void TagGroupsSpeciesWriteAscii_g(WorkSpace&, const MRecord& mr)
{
  TagGroups *GI0 = *wsv_pointers[mr.Input()[0]];
  TagGroupsSpeciesWriteAscii(*GI0,
                             wsv_data[mr.Input()[0]].Name(),
                             mr.Values()[0]);
}
 
void LosWriteBinary_g(WorkSpace&, const MRecord& mr)
{
  Los *GI0 = *wsv_pointers[mr.Input()[0]];
  LosWriteBinary(*GI0,
                 wsv_data[mr.Input()[0]].Name(),
                 mr.Values()[0]);
}
 
void LosReadBinary_g(WorkSpace&, const MRecord& mr)
{
  Los *GO0 = *wsv_pointers[mr.Output()[0]];
  LosReadBinary(*GO0,
                wsv_data[mr.Output()[0]].Name(),
                mr.Values()[0]);
}
 
void lines_per_tgSetEmpty_g(WorkSpace& ws, const MRecord&)
{
  lines_per_tgSetEmpty(ws.lines_per_tg,
                       ws.tgs);
}
 
void lines_per_tgReadFromCatalogues_g(WorkSpace& ws, const MRecord& mr)
{
  lines_per_tgReadFromCatalogues(ws.lines_per_tg,
                                 ws.tgs,
                                 mr.Values()[0],
                                 mr.Values()[1],
                                 mr.Values()[2],
                                 mr.Values()[3]);
}
 
void linesReadFromHitran_g(WorkSpace& ws, const MRecord& mr)
{
  linesReadFromHitran(ws.lines,
                      mr.Values()[0],
                      mr.Values()[1],
                      mr.Values()[2]);
}
 
void linesReadFromHitran2004_g(WorkSpace& ws, const MRecord& mr)
{
  linesReadFromHitran2004(ws.lines,
                          mr.Values()[0],
                          mr.Values()[1],
                          mr.Values()[2]);
}
 
void linesReadFromMytran2_g(WorkSpace& ws, const MRecord& mr)
{
  linesReadFromMytran2(ws.lines,
                       mr.Values()[0],
                       mr.Values()[1],
                       mr.Values()[2]);
}
 
void linesReadFromJpl_g(WorkSpace& ws, const MRecord& mr)
{
  linesReadFromJpl(ws.lines,
                   mr.Values()[0],
                   mr.Values()[1],
                   mr.Values()[2]);
}
 
void linesReadFromArts_g(WorkSpace& ws, const MRecord& mr)
{
  linesReadFromArts(ws.lines,
                    mr.Values()[0],
                    mr.Values()[1],
                    mr.Values()[2]);
}
 
void linesElowToJoule_g(WorkSpace& ws, const MRecord&)
{
  linesElowToJoule(ws.lines);
}
 
void lines_per_tgCreateFromLines_g(WorkSpace& ws, const MRecord&)
{
  lines_per_tgCreateFromLines(ws.lines_per_tg,
                              ws.lines,
                              ws.tgs);
}
 
void lines_per_tgAddMirrorLines_g(WorkSpace& ws, const MRecord&)
{
  lines_per_tgAddMirrorLines(ws.lines_per_tg);
}
 
void lines_per_tgCompact_g(WorkSpace& ws, const MRecord&)
{
  lines_per_tgCompact(ws.lines_per_tg,
                      ws.lineshape,
                      ws.f_mono);
}
 
void linesWriteAscii_g(WorkSpace& ws, const MRecord& mr)
{
  linesWriteAscii(ws.lines,
                  mr.Values()[0]);
}
 
void lines_per_tgWriteAscii_g(WorkSpace& ws, const MRecord& mr)
{
  lines_per_tgWriteAscii(ws.lines_per_tg,
                         mr.Values()[0]);
}
 
void tgsDefine_g(WorkSpace& ws, const MRecord& mr)
{
  tgsDefine(ws.tgs,
            mr.Values()[0]);
}
 
void tgsDefineAllInScenario_g(WorkSpace& ws, const MRecord& mr)
{
  tgsDefineAllInScenario(ws.tgs,
                         mr.Values()[0]);
}
 
void lineshapeDefine_g(WorkSpace& ws, const MRecord& mr)
{
  lineshapeDefine(ws.lineshape,
                  ws.tgs,
                  mr.Values()[0],
                  mr.Values()[1],
                  mr.Values()[2]);
}
 
void lineshape_per_tgDefine_g(WorkSpace& ws, const MRecord& mr)
{
  lineshape_per_tgDefine(ws.lineshape,
                         ws.tgs,
                         mr.Values()[0],
                         mr.Values()[1],
                         mr.Values()[2]);
}
 
void cont_descriptionInit_g(WorkSpace& ws, const MRecord&)
{
  cont_descriptionInit(ws.cont_description_names,
                       ws.cont_description_models,
                       ws.cont_description_parameters);
}
 
void cont_descriptionAppend_g(WorkSpace& ws, const MRecord& mr)
{
  cont_descriptionAppend(ws.cont_description_names,
                         ws.cont_description_models,
                         ws.cont_description_parameters,
                         mr.Values()[0],
                         mr.Values()[1],
                         mr.Values()[2]);
}
 
void raw_vmrsReadFromFiles_g(WorkSpace& ws, const MRecord& mr)
{
  raw_vmrsReadFromFiles(ws.raw_vmrs,
                        ws.tgs,
                        mr.Values()[0],
                        mr.Values()[1],
                        mr.Values()[2]);
}
 
void raw_vmrsReadFromScenario_g(WorkSpace& ws, const MRecord& mr)
{
  raw_vmrsReadFromScenario(ws.raw_vmrs,
                           ws.tgs,
                           mr.Values()[0]);
}
 
void AtmFromRaw_g(WorkSpace& ws, const MRecord&)
{
  AtmFromRaw(ws.t_abs,
             ws.z_abs,
             ws.vmrs,
             ws.tgs,
             ws.p_abs,
             ws.raw_ptz,
             ws.raw_vmrs);
}
 
void WaterVaporSaturationInClouds_g(WorkSpace& ws, const MRecord&)
{
  WaterVaporSaturationInClouds(ws.vmrs,
                               ws.p_abs,
                               ws.t_abs,
                               ws.tgs);
}
 
void vmrsScale_g(WorkSpace& ws, const MRecord& mr)
{
  vmrsScale(ws.vmrs,
            ws.tgs,
            mr.Values()[0],
            mr.Values()[1]);
}
 
void h2o_absSet_g(WorkSpace& ws, const MRecord&)
{
  h2o_absSet(ws.h2o_abs,
             ws.tgs,
             ws.vmrs);
}
 
void n2_absSet_g(WorkSpace& ws, const MRecord&)
{
  n2_absSet(ws.n2_abs,
            ws.tgs,
            ws.vmrs);
}
 
void hseSet_g(WorkSpace& ws, const MRecord& mr)
{
  hseSet(ws.hse,
         mr.Values()[0],
         mr.Values()[1],
         mr.Values()[2],
         mr.Values()[3]);
}
 
void hseSetFromLatitude_g(WorkSpace& ws, const MRecord& mr)
{
  hseSetFromLatitude(ws.hse,
                     mr.Values()[0],
                     mr.Values()[1],
                     mr.Values()[2],
                     mr.Values()[3]);
}
 
void hseSetFromLatitudeIndex_g(WorkSpace& ws, const MRecord& mr)
{
  hseSetFromLatitudeIndex(ws.hse,
                          ws.p_abs,
                          ws.z_abs,
                          mr.Values()[0],
                          mr.Values()[1],
                          mr.Values()[2]);
}
 
void hseFromBottom_g(WorkSpace& ws, const MRecord& mr)
{
  hseFromBottom(ws.hse,
                ws.p_abs,
                ws.z_abs,
                mr.Values()[0],
                mr.Values()[1]);
}
 
void hseOff_g(WorkSpace& ws, const MRecord&)
{
  hseOff(ws.hse);
}
 
void hseCalc_g(WorkSpace& ws, const MRecord&)
{
  hseCalc(ws.z_abs,
          ws.p_abs,
          ws.t_abs,
          ws.h2o_abs,
          ws.r_geoid,
          ws.hse);
}
 
void absCalc_g(WorkSpace& ws, const MRecord&)
{
  absCalc(ws.abs,
          ws.abs_per_tg,
          ws.tgs,
          ws.f_mono,
          ws.p_abs,
          ws.t_abs,
          ws.n2_abs,
          ws.h2o_abs,
          ws.vmrs,
          ws.lines_per_tg,
          ws.lineshape,
          ws.cont_description_names,
          ws.cont_description_models,
          ws.cont_description_parameters);
}
 
void absCalcSaveMemory_g(WorkSpace& ws, const MRecord&)
{
  absCalcSaveMemory(ws.abs,
                    ws.tgs,
                    ws.f_mono,
                    ws.p_abs,
                    ws.t_abs,
                    ws.n2_abs,
                    ws.h2o_abs,
                    ws.vmrs,
                    ws.lines_per_tg,
                    ws.lineshape,
                    ws.cont_description_names,
                    ws.cont_description_models,
                    ws.cont_description_parameters);
}
 
void absCalcFromXsec_g(WorkSpace& ws, const MRecord&)
{
  absCalcFromXsec(ws.abs,
                  ws.abs_per_tg,
                  ws.xsec_per_tg,
                  ws.vmrs);
}
 
void xsec_per_tgInit_g(WorkSpace& ws, const MRecord&)
{
  xsec_per_tgInit(ws.xsec_per_tg,
                  ws.tgs,
                  ws.f_mono,
                  ws.p_abs);
}
 
void xsec_per_tgAddLines_g(WorkSpace& ws, const MRecord&)
{
  xsec_per_tgAddLines(ws.xsec_per_tg,
                      ws.tgs,
                      ws.f_mono,
                      ws.p_abs,
                      ws.t_abs,
                      ws.h2o_abs,
                      ws.vmrs,
                      ws.lines_per_tg,
                      ws.lineshape);
}
 
void xsec_per_tgAddConts_g(WorkSpace& ws, const MRecord&)
{
  xsec_per_tgAddConts(ws.xsec_per_tg,
                      ws.tgs,
                      ws.f_mono,
                      ws.p_abs,
                      ws.t_abs,
                      ws.n2_abs,
                      ws.h2o_abs,
                      ws.vmrs,
                      ws.cont_description_names,
                      ws.cont_description_parameters,
                      ws.cont_description_models);
}
 
void abs_per_tgReduce_g(WorkSpace& ws, const MRecord&)
{
  abs_per_tgReduce(ws.abs_per_tg,
                   ws.tgs,
                   ws.wfs_tgs);
}
 
void refrSet_g(WorkSpace& ws, const MRecord& mr)
{
  refrSet(ws.refr,
          ws.refr_lfac,
          ws.refr_model,
          mr.Values()[0],
          mr.Values()[1],
          mr.Values()[2]);
}
 
void refrOff_g(WorkSpace& ws, const MRecord&)
{
  refrOff(ws.refr,
          ws.refr_lfac,
          ws.refr_model);
}
 
void refrCalc_g(WorkSpace& ws, const MRecord&)
{
  refrCalc(ws.refr_index,
           ws.p_abs,
           ws.t_abs,
           ws.h2o_abs,
           ws.refr,
           ws.refr_model);
}
 
void zaFromZtan_g(WorkSpace& ws, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  zaFromZtan(*GO0,
             wsv_data[mr.Output()[0]].Name(),
             ws.z_tan,
             ws.z_plat,
             ws.p_abs,
             ws.z_abs,
             ws.refr,
             ws.refr_index,
             ws.r_geoid,
             ws.z_ground);
}
 
void zaFromDeltat_g(WorkSpace& ws, const MRecord& mr)
{
  Vector *GO0 = *wsv_pointers[mr.Output()[0]];
  zaFromDeltat(*GO0,
               wsv_data[mr.Output()[0]].Name(),
               ws.z_plat,
               ws.p_abs,
               ws.z_abs,
               ws.l_step,
               ws.refr,
               ws.refr_lfac,
               ws.refr_index,
               ws.r_geoid,
               ws.z_ground,
               mr.Values()[0],
               mr.Values()[1]);
}
 
void r_geoidStd_g(WorkSpace& ws, const MRecord&)
{
  r_geoidStd(ws.r_geoid);
}
 
void r_geoidWGS84_g(WorkSpace& ws, const MRecord& mr)
{
  r_geoidWGS84(ws.r_geoid,
               mr.Values()[0],
               mr.Values()[1]);
}
 
void groundOff_g(WorkSpace& ws, const MRecord&)
{
  groundOff(ws.z_ground,
            ws.t_ground,
            ws.e_ground,
            ws.z_abs);
}
 
void groundSet_g(WorkSpace& ws, const MRecord& mr)
{
  groundSet(ws.z_ground,
            ws.t_ground,
            ws.e_ground,
            ws.p_abs,
            ws.t_abs,
            ws.z_abs,
            ws.f_mono,
            mr.Values()[0],
            mr.Values()[1]);
}
 
void groundAtBottom_g(WorkSpace& ws, const MRecord& mr)
{
  groundAtBottom(ws.z_ground,
                 ws.t_ground,
                 ws.e_ground,
                 ws.t_abs,
                 ws.z_abs,
                 ws.f_mono,
                 mr.Values()[0]);
}
 
void groundFlatSea_g(WorkSpace& ws, const MRecord& mr)
{
  groundFlatSea(ws.z_ground,
                ws.t_ground,
                ws.e_ground,
                ws.p_abs,
                ws.t_abs,
                ws.z_abs,
                ws.f_mono,
                ws.za_pencil,
                ws.z_plat,
                ws.r_geoid,
                ws.refr,
                ws.refr_index,
                mr.Values()[0],
                mr.Values()[1]);
}
 
void emissionOn_g(WorkSpace& ws, const MRecord&)
{
  emissionOn(ws.emission);
}
 
void emissionOff_g(WorkSpace& ws, const MRecord&)
{
  emissionOff(ws.emission);
}
 
void losCalc_g(WorkSpace& ws, const MRecord&)
{
  losCalc(ws.los,
          ws.z_tan,
          ws.z_plat,
          ws.za_pencil,
          ws.l_step,
          ws.p_abs,
          ws.z_abs,
          ws.refr,
          ws.refr_lfac,
          ws.refr_index,
          ws.z_ground,
          ws.r_geoid);
}
 
void sourceCalc_g(WorkSpace& ws, const MRecord&)
{
  sourceCalc(ws.source,
             ws.emission,
             ws.los,
             ws.p_abs,
             ws.t_abs,
             ws.f_mono);
}
 
void transCalc_g(WorkSpace& ws, const MRecord&)
{
  transCalc(ws.trans,
            ws.los,
            ws.p_abs,
            ws.abs);
}
 
void y_spaceStd_g(WorkSpace& ws, const MRecord& mr)
{
  y_spaceStd(ws.y_space,
             ws.f_mono,
             mr.Values()[0]);
}
 
void yCalc_g(WorkSpace& ws, const MRecord&)
{
  yCalc(ws.y,
        ws.emission,
        ws.los,
        ws.f_mono,
        ws.y_space,
        ws.source,
        ws.trans,
        ws.e_ground,
        ws.t_ground);
}
 
void sourcetransyCalcSaveMemory_g(WorkSpace& ws, const MRecord& mr)
{
  sourcetransyCalcSaveMemory(ws.y,
                             ws.emission,
                             ws.los,
                             ws.p_abs,
                             ws.t_abs,
                             ws.f_mono,
                             ws.abs,
                             ws.y_space,
                             ws.e_ground,
                             ws.t_ground,
                             mr.Values()[0]);
}
 
void CoolingRates_g(WorkSpace& ws, const MRecord& mr)
{
  CoolingRates(ws.coolrate,
               ws.l_step,
               ws.p_abs,
               ws.z_abs,
               ws.t_abs,
               ws.f_mono,
               ws.abs,
               ws.za_pencil,
               ws.refr,
               ws.refr_lfac,
               ws.refr_index,
               ws.r_geoid,
               ws.z_ground,
               ws.e_ground,
               ws.t_ground,
               ws.p_coolrate,
               mr.Values()[0]);
}
 
void yTB_g(WorkSpace& ws, const MRecord&)
{
  yTB(ws.y,
      ws.f_mono,
      ws.za_pencil);
}
 
void MatrixTB_g(WorkSpace& ws, const MRecord& mr)
{
  Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
  Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
  MatrixTB(*GO0,
           wsv_data[mr.Output()[0]].Name(),
           ws.f_mono,
           ws.za_pencil,
           *GI0,
           wsv_data[mr.Input()[0]].Name());
}
 
void yTRJ_g(WorkSpace& ws, const MRecord&)
{
  yTRJ(ws.y,
       ws.f_mono,
       ws.za_pencil);
}
 
void MatrixTRJ_g(WorkSpace& ws, const MRecord& mr)
{
  Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
  Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
  MatrixTRJ(*GO0,
            wsv_data[mr.Output()[0]].Name(),
            ws.f_mono,
            ws.za_pencil,
            *GI0,
            wsv_data[mr.Input()[0]].Name());
}
 
void wfs_tgsDefine_g(WorkSpace& ws, const MRecord& mr)
{
  wfs_tgsDefine(ws.wfs_tgs,
                mr.Values()[0]);
}
 
void wfss_tgsDefine_g(WorkSpace& ws, const MRecord& mr)
{
  wfss_tgsDefine(ws.wfss_tgs,
                 mr.Values()[0]);
}
 
void absloswfsCalc_g(WorkSpace& ws, const MRecord&)
{
  absloswfsCalc(ws.absloswfs,
                ws.emission,
                ws.los,
                ws.source,
                ws.trans,
                ws.y,
                ws.y_space,
                ws.f_mono,
                ws.e_ground,
                ws.t_ground);
}
 
void kSpecies_g(WorkSpace& ws, const MRecord& mr)
{
  kSpecies(ws.k,
           ws.k_names,
           ws.k_aux,
           ws.los,
           ws.absloswfs,
           ws.p_abs,
           ws.t_abs,
           ws.wfs_tgs,
           ws.abs_per_tg,
           ws.vmrs,
           ws.k_grid,
           mr.Values()[0]);
}
 
void kSpeciesSingle_g(WorkSpace& ws, const MRecord& mr)
{
  kSpeciesSingle(ws.k,
                 ws.k_names,
                 ws.k_aux,
                 ws.los,
                 ws.absloswfs,
                 ws.p_abs,
                 ws.t_abs,
                 ws.wfs_tgs,
                 ws.abs_per_tg,
                 ws.vmrs,
                 ws.k_grid,
                 mr.Values()[0],
                 mr.Values()[1]);
}
 
void kContAbs_g(WorkSpace& ws, const MRecord& mr)
{
  kContAbs(ws.k,
           ws.k_names,
           ws.k_aux,
           ws.los,
           ws.absloswfs,
           ws.f_mono,
           ws.k_grid,
           mr.Values()[0],
           mr.Values()[1],
           mr.Values()[2],
           mr.Values()[3]);
}
 
void kTemp_g(WorkSpace& ws, const MRecord& mr)
{
  kTemp(ws.k,
        ws.k_names,
        ws.k_aux,
        ws.tgs,
        ws.f_mono,
        ws.p_abs,
        ws.t_abs,
        ws.n2_abs,
        ws.h2o_abs,
        ws.vmrs,
        ws.abs,
        ws.lines_per_tg,
        ws.lineshape,
        ws.e_ground,
        ws.emission,
        ws.k_grid,
        ws.cont_description_names,
        ws.cont_description_parameters,
        ws.cont_description_models,
        ws.los,
        ws.absloswfs,
        ws.trans,
        ws.z_plat,
        ws.za_pencil,
        ws.l_step,
        ws.z_abs,
        ws.refr,
        ws.refr_lfac,
        ws.refr_index,
        ws.refr_model,
        ws.z_ground,
        ws.t_ground,
        ws.y_space,
        ws.r_geoid,
        ws.hse,
        mr.Values()[0],
        mr.Values()[1]);
}
 
void kSpectro_g(WorkSpace& ws, const MRecord& mr)
{
  kSpectro(ws.k,
           ws.k_names,
           ws.k_aux,
           ws.S_S,
           ws.wfss_tgs,
           ws.tgs,
           ws.f_mono,
           ws.p_abs,
           ws.t_abs,
           ws.z_abs,
           ws.h2o_abs,
           ws.vmrs,
           ws.lines_per_tg,
           ws.lineshape,
           ws.los,
           ws.absloswfs,
           mr.Values()[0],
           mr.Values()[1],
           mr.Values()[2],
           mr.Values()[3],
           mr.Values()[4],
           mr.Values()[5],
           mr.Values()[6]);
}
 
void kFrequencyOffSet_g(WorkSpace& ws, const MRecord& mr)
{
  kFrequencyOffSet(ws.k,
                   ws.k_names,
                   ws.k_aux,
                   ws.tgs,
                   ws.f_mono,
                   ws.p_abs,
                   ws.t_abs,
                   ws.n2_abs,
                   ws.h2o_abs,
                   ws.vmrs,
                   ws.lines_per_tg,
                   ws.lineshape,
                   ws.e_ground,
                   ws.emission,
                   ws.cont_description_names,
                   ws.cont_description_parameters,
                   ws.cont_description_models,
                   ws.los,
                   ws.t_ground,
                   ws.y_space,
                   ws.y,
                   mr.Values()[0],
                   mr.Values()[1]);
}
 
void kPointingOffSet_g(WorkSpace& ws, const MRecord& mr)
{
  kPointingOffSet(ws.k,
                  ws.k_names,
                  ws.k_aux,
                  ws.z_plat,
                  ws.za_pencil,
                  ws.l_step,
                  ws.p_abs,
                  ws.z_abs,
                  ws.t_abs,
                  ws.f_mono,
                  ws.refr,
                  ws.refr_lfac,
                  ws.refr_index,
                  ws.z_ground,
                  ws.r_geoid,
                  ws.abs,
                  ws.emission,
                  ws.y_space,
                  ws.e_ground,
                  ws.t_ground,
                  ws.y,
                  mr.Values()[0]);
}
 
void kEground_g(WorkSpace& ws, const MRecord& mr)
{
  kEground(ws.k,
           ws.k_names,
           ws.k_aux,
           ws.za_pencil,
           ws.f_mono,
           ws.emission,
           ws.y_space,
           ws.e_ground,
           ws.t_ground,
           ws.los,
           ws.source,
           ws.trans,
           mr.Values()[0]);
}
 
void kCalibration_g(WorkSpace& ws, const MRecord& mr)
{
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  kCalibration(ws.k,
               ws.k_names,
               ws.k_aux,
               ws.y,
               ws.f_mono,
               *GI0,
               wsv_data[mr.Input()[0]].Name());
}
 
void kManual_g(WorkSpace& ws, const MRecord& mr)
{
  kManual(ws.k,
          ws.k_names,
          ws.k_aux,
          ws.y0,
          ws.y,
          mr.Values()[0],
          mr.Values()[1],
          mr.Values()[2],
          mr.Values()[3]);
}
 
void kxInit_g(WorkSpace& ws, const MRecord&)
{
  kxInit(ws.kx,
         ws.kx_names,
         ws.kx_lengths,
         ws.kx_aux);
}
 
void kbInit_g(WorkSpace& ws, const MRecord&)
{
  kbInit(ws.kb,
         ws.kb_names,
         ws.kb_lengths,
         ws.kb_aux);
}
 
void kxAppend_g(WorkSpace& ws, const MRecord&)
{
  kxAppend(ws.kx,
           ws.kx_names,
           ws.kx_lengths,
           ws.kx_aux,
           ws.k,
           ws.k_names,
           ws.k_aux);
}
 
void kbAppend_g(WorkSpace& ws, const MRecord&)
{
  kbAppend(ws.kb,
           ws.kb_names,
           ws.kb_lengths,
           ws.kb_aux,
           ws.k,
           ws.k_names,
           ws.k_aux);
}
 
void kxAllocate_g(WorkSpace& ws, const MRecord& mr)
{
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  kxAllocate(ws.kx,
             ws.kx_names,
             ws.kx_lengths,
             ws.kx_aux,
             *GI0,
             wsv_data[mr.Input()[0]].Name(),
             mr.Values()[0],
             mr.Values()[1]);
}
 
void kbAllocate_g(WorkSpace& ws, const MRecord& mr)
{
  Vector *GI0 = *wsv_pointers[mr.Input()[0]];
  kbAllocate(ws.kb,
             ws.kb_names,
             ws.kb_lengths,
             ws.kb_aux,
             *GI0,
             wsv_data[mr.Input()[0]].Name(),
             mr.Values()[0],
             mr.Values()[1]);
}
 
void kxPutInK_g(WorkSpace& ws, const MRecord&)
{
  kxPutInK(ws.kx,
           ws.kx_names,
           ws.kx_lengths,
           ws.kx_aux,
           ws.k,
           ws.k_names,
           ws.k_aux);
}
 
void kbPutInK_g(WorkSpace& ws, const MRecord&)
{
  kbPutInK(ws.kb,
           ws.kb_names,
           ws.kb_lengths,
           ws.kb_aux,
           ws.k,
           ws.k_names,
           ws.k_aux);
}
 
void ybatchCalc_g(WorkSpace& ws, const MRecord& mr)
{
  ybatchCalc(ws.ybatch,
             ws.f_mono,
             ws.p_abs,
             ws.t_abs,
             ws.n2_abs,
             ws.h2o_abs,
             ws.vmrs,
             ws.lines_per_tg,
             ws.lineshape,
             ws.z_abs,
             ws.z_plat,
             ws.za_pencil,
             ws.l_step,
             ws.refr,
             ws.refr_lfac,
             ws.refr_index,
             ws.z_ground,
             ws.r_geoid,
             ws.emission,
             ws.y_space,
             ws.e_ground,
             ws.t_ground,
             ws.batchname,
             ws.tgs,
             ws.cont_description_names,
             ws.cont_description_parameters,
             ws.cont_description_models,
             mr.Values()[0],
             mr.Values()[1],
             mr.Values()[2],
             mr.Values()[3],
             mr.Values()[4],
             mr.Values()[5],
             mr.Values()[6],
             mr.Values()[7],
             mr.Values()[8],
             mr.Values()[9],
             mr.Values()[10]);
}
 
void ybatchFromRadiosonde_g(WorkSpace& ws, const MRecord& mr)
{
  ybatchFromRadiosonde(ws.ybatch,
                       ws.absbatch,
                       ws.jacbatch,
                       ws.radiosonde_data,
                       ws.f_mono,
                       ws.lines_per_tg,
                       ws.lineshape,
                       ws.z_plat,
                       ws.za_pencil,
                       ws.l_step,
                       ws.refr,
                       ws.refr_model,
                       ws.refr_lfac,
                       ws.r_geoid,
                       ws.emission,
                       ws.y_space,
                       ws.e_ground,
                       ws.tgs,
                       ws.cont_description_names,
                       ws.cont_description_models,
                       ws.cont_description_parameters,
                       mr.Values()[0],
                       mr.Values()[1],
                       mr.Values()[2],
                       mr.Values()[3],
                       mr.Values()[4],
                       mr.Values()[5]);
}
 
void ybatchFromRadiosondeGlobal_g(WorkSpace& ws, const MRecord&)
{
  ybatchFromRadiosondeGlobal(ws.ybatch,
                             ws.radiosonde_data,
                             ws.f_mono,
                             ws.lines_per_tg,
                             ws.lineshape,
                             ws.z_plat,
                             ws.za_pencil,
                             ws.l_step,
                             ws.refr,
                             ws.refr_model,
                             ws.refr_lfac,
                             ws.r_geoid,
                             ws.emission,
                             ws.y_space,
                             ws.e_ground,
                             ws.tgs,
                             ws.cont_description_names,
                             ws.cont_description_models,
                             ws.cont_description_parameters);
}
 
void MethodListDefine_g(WorkSpace&, const MRecord& mr)
{
  ArrayOfIndex *GO0 = *wsv_pointers[mr.Output()[0]];
  MethodListDefine(*GO0,
                   wsv_data[mr.Output()[0]].Name(),
                   mr.Values()[0]);
}
 
// The array holding the pointers to the getaway functions.
void (*getaways[])(WorkSpace&, const MRecord&)
  = {Echo_g,
     Exit_g,
     Test_g,
     IndexSet_g,
     IndexWriteAscii_g,
     IndexReadAscii_g,
     IndexWriteBinary_g,
     IndexReadBinary_g,
     NumericSet_g,
     NumericCopyFirstOfVector_g,
     NumericCopyLastOfVector_g,
     NumericWriteAscii_g,
     NumericReadAscii_g,
     NumericWriteBinary_g,
     NumericReadBinary_g,
     VectorCopy_g,
     VectorCopyFromMatrix_g,
     VectorSet_g,
     VectorSetLengthFromVector_g,
     VectorLinSpace_g,
     VectorNLinSpace_g,
     VectorNLogSpace_g,
     VectorPressuresForLinAltitudes_g,
     VectorFlip_g,
     VectorMatrixMultiply_g,
     VectorWriteAscii_g,
     VectorReadAscii_g,
     VectorWriteBinary_g,
     VectorReadBinary_g,
     VectorPlanck_g,
     VectorCalcLog10_g,
     VectorAdd_g,
     VectorScale_g,
     MatrixSet_g,
     MatrixCopy_g,
     MatrixFillWithVector_g,
     MatrixMatrixMultiply_g,
     ArrayOfMatrixMatrixMultiply_g,
     MatrixMatrixAdd_g,
     MatrixWriteAscii_g,
     MatrixReadAscii_g,
     MatrixWriteBinary_g,
     MatrixReadBinary_g,
     MatrixScale_g,
     MatrixDiagonal_g,
     ArrayOfIndexWriteAscii_g,
     ArrayOfIndexReadAscii_g,
     ArrayOfIndexWriteBinary_g,
     ArrayOfIndexReadBinary_g,
     ArrayOfVectorWriteAscii_g,
     ArrayOfVectorReadAscii_g,
     ArrayOfVectorWriteBinary_g,
     ArrayOfVectorReadBinary_g,
     ArrayOfMatrixWriteAscii_g,
     ArrayOfMatrixReadAscii_g,
     ArrayOfMatrixWriteBinary_g,
     ArrayOfMatrixReadBinary_g,
     StringSet_g,
     StringWriteAscii_g,
     StringReadAscii_g,
     StringWriteBinary_g,
     StringReadBinary_g,
     ArrayOfStringSet_g,
     ArrayOfStringWriteAscii_g,
     ArrayOfStringReadAscii_g,
     ArrayOfStringWriteBinary_g,
     ArrayOfStringReadBinary_g,
     TagGroupsSpeciesWriteAscii_g,
     LosWriteBinary_g,
     LosReadBinary_g,
     lines_per_tgSetEmpty_g,
     lines_per_tgReadFromCatalogues_g,
     linesReadFromHitran_g,
     linesReadFromHitran2004_g,
     linesReadFromMytran2_g,
     linesReadFromJpl_g,
     linesReadFromArts_g,
     linesElowToJoule_g,
     lines_per_tgCreateFromLines_g,
     lines_per_tgAddMirrorLines_g,
     lines_per_tgCompact_g,
     linesWriteAscii_g,
     lines_per_tgWriteAscii_g,
     tgsDefine_g,
     tgsDefineAllInScenario_g,
     lineshapeDefine_g,
     lineshape_per_tgDefine_g,
     cont_descriptionInit_g,
     cont_descriptionAppend_g,
     raw_vmrsReadFromFiles_g,
     raw_vmrsReadFromScenario_g,
     AtmFromRaw_g,
     WaterVaporSaturationInClouds_g,
     vmrsScale_g,
     h2o_absSet_g,
     n2_absSet_g,
     hseSet_g,
     hseSetFromLatitude_g,
     hseSetFromLatitudeIndex_g,
     hseFromBottom_g,
     hseOff_g,
     hseCalc_g,
     absCalc_g,
     absCalcSaveMemory_g,
     absCalcFromXsec_g,
     xsec_per_tgInit_g,
     xsec_per_tgAddLines_g,
     xsec_per_tgAddConts_g,
     abs_per_tgReduce_g,
     refrSet_g,
     refrOff_g,
     refrCalc_g,
     zaFromZtan_g,
     zaFromDeltat_g,
     r_geoidStd_g,
     r_geoidWGS84_g,
     groundOff_g,
     groundSet_g,
     groundAtBottom_g,
     groundFlatSea_g,
     emissionOn_g,
     emissionOff_g,
     losCalc_g,
     sourceCalc_g,
     transCalc_g,
     y_spaceStd_g,
     yCalc_g,
     sourcetransyCalcSaveMemory_g,
     CoolingRates_g,
     yTB_g,
     MatrixTB_g,
     yTRJ_g,
     MatrixTRJ_g,
     wfs_tgsDefine_g,
     wfss_tgsDefine_g,
     absloswfsCalc_g,
     kSpecies_g,
     kSpeciesSingle_g,
     kContAbs_g,
     kTemp_g,
     kSpectro_g,
     kFrequencyOffSet_g,
     kPointingOffSet_g,
     kEground_g,
     kCalibration_g,
     kManual_g,
     kxInit_g,
     kbInit_g,
     kxAppend_g,
     kbAppend_g,
     kxAllocate_g,
     kbAllocate_g,
     kxPutInK_g,
     kbPutInK_g,
     ybatchCalc_g,
     ybatchFromRadiosonde_g,
     ybatchFromRadiosondeGlobal_g,
     MethodListDefine_g};