arts-docs-2.4/doxygen/autoarts_8h_source.html

#ifndef autoarts_h

#define autoarts_h


#include <auto_md.h>

#include <arts.h>

#include <global_data.h>

#include <m_basic_types.h>

#include <m_general.h>

#include <m_append.h>

#include <m_conversion.h>

#include <m_copy.h>

#include <m_gridded_fields.h>

#include <m_xml.h>

#include <m_select.h>

#include <m_reduce.h>

#include <m_nc.h>

#include <m_delete.h>

#include <m_extract.h>

#include <m_ignore.h>


extern String out_basename;


namespace ARTS { using Workspace=Workspace; }


namespace ARTS::Group {

using AbsorptionLines=AbsorptionLines;

using Agenda=Agenda;

using ArrayOfAbsorptionLines=ArrayOfAbsorptionLines;

using ArrayOfAgenda=ArrayOfAgenda;

using ArrayOfArrayOfAbsorptionLines=ArrayOfArrayOfAbsorptionLines;

using ArrayOfArrayOfGriddedField1=ArrayOfArrayOfGriddedField1;

using ArrayOfArrayOfGriddedField2=ArrayOfArrayOfGriddedField2;

using ArrayOfArrayOfGriddedField3=ArrayOfArrayOfGriddedField3;

using ArrayOfArrayOfIndex=ArrayOfArrayOfIndex;

using ArrayOfArrayOfMatrix=ArrayOfArrayOfMatrix;

using ArrayOfArrayOfPropagationMatrix=ArrayOfArrayOfPropagationMatrix;

using ArrayOfArrayOfRadiationVector=ArrayOfArrayOfRadiationVector;

using ArrayOfArrayOfScatteringMetaData=ArrayOfArrayOfScatteringMetaData;

using ArrayOfArrayOfSingleScatteringData=ArrayOfArrayOfSingleScatteringData;

using ArrayOfArrayOfSpeciesTag=ArrayOfArrayOfSpeciesTag;

using ArrayOfArrayOfStokesVector=ArrayOfArrayOfStokesVector;

using ArrayOfArrayOfString=ArrayOfArrayOfString;

using ArrayOfArrayOfTensor3=ArrayOfArrayOfTensor3;

using ArrayOfArrayOfTensor6=ArrayOfArrayOfTensor6;

using ArrayOfArrayOfTime=ArrayOfArrayOfTime;

using ArrayOfArrayOfTransmissionMatrix=ArrayOfArrayOfTransmissionMatrix;

using ArrayOfArrayOfVector=ArrayOfArrayOfVector;

using ArrayOfCIARecord=ArrayOfCIARecord;

using ArrayOfGriddedField1=ArrayOfGriddedField1;

using ArrayOfGriddedField2=ArrayOfGriddedField2;

using ArrayOfGriddedField3=ArrayOfGriddedField3;

using ArrayOfGriddedField4=ArrayOfGriddedField4;

using ArrayOfIndex=ArrayOfIndex;

using ArrayOfMatrix=ArrayOfMatrix;

using ArrayOfPpath=ArrayOfPpath;

using ArrayOfPropagationMatrix=ArrayOfPropagationMatrix;

using ArrayOfQuantumIdentifier=ArrayOfQuantumIdentifier;

using ArrayOfRadiationVector=ArrayOfRadiationVector;

using ArrayOfRetrievalQuantity=ArrayOfRetrievalQuantity;

using ArrayOfScatteringMetaData=ArrayOfScatteringMetaData;

using ArrayOfSingleScatteringData=ArrayOfSingleScatteringData;

using ArrayOfSparse=ArrayOfSparse;

using ArrayOfStokesVector=ArrayOfStokesVector;

using ArrayOfString=ArrayOfString;

using ArrayOfTelsemAtlas=ArrayOfTelsemAtlas;

using ArrayOfTensor3=ArrayOfTensor3;

using ArrayOfTensor4=ArrayOfTensor4;

using ArrayOfTensor5=ArrayOfTensor5;

using ArrayOfTensor6=ArrayOfTensor6;

using ArrayOfTensor7=ArrayOfTensor7;

using ArrayOfTime=ArrayOfTime;

using ArrayOfTransmissionMatrix=ArrayOfTransmissionMatrix;

using ArrayOfVector=ArrayOfVector;

using ArrayOfXsecRecord=ArrayOfXsecRecord;

using CIARecord=CIARecord;

using CovarianceMatrix=CovarianceMatrix;

using EnergyLevelMap=EnergyLevelMap;

using GasAbsLookup=GasAbsLookup;

using GridPos=GridPos;

using GriddedField1=GriddedField1;

using GriddedField2=GriddedField2;

using GriddedField3=GriddedField3;

using GriddedField4=GriddedField4;

using GriddedField5=GriddedField5;

using GriddedField6=GriddedField6;

using HitranRelaxationMatrixData=HitranRelaxationMatrixData;

using Index=Index;

using MCAntenna=MCAntenna;

using Matrix=Matrix;

using Numeric=Numeric;

using Ppath=Ppath;

using PropagationMatrix=PropagationMatrix;

using QuantumIdentifier=QuantumIdentifier;

using RadiationVector=RadiationVector;

using Rational=Rational;

using ScatteringMetaData=ScatteringMetaData;

using SingleScatteringData=SingleScatteringData;

using Sparse=Sparse;

using SpeciesAuxData=SpeciesAuxData;

using StokesVector=StokesVector;

using String=String;

using TelsemAtlas=TelsemAtlas;

using Tensor3=Tensor3;

using Tensor4=Tensor4;

using Tensor5=Tensor5;

using Tensor6=Tensor6;

using Tensor7=Tensor7;

using TessemNN=TessemNN;

using Time=Time;

using Timer=Timer;

using TransmissionMatrix=TransmissionMatrix;

using Vector=Vector;

using Verbosity=Verbosity;

}  // ARTS::Group


namespace ARTS::Var {

class AbsorptionLines {

  using type = Group::AbsorptionLines;

  std::size_t p;

  type* v;

public:

  AbsorptionLines() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  AbsorptionLines(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~AbsorptionLines() noexcept {if (islast() and not isnull()) delete v;}

  AbsorptionLines(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  AbsorptionLines& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Agenda {

  using type = Group::Agenda;

  std::size_t p;

  type* v;

public:

  Agenda() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Agenda(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Agenda() noexcept {if (islast() and not isnull()) delete v;}

  Agenda(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Agenda& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfAbsorptionLines {

  using type = Group::ArrayOfAbsorptionLines;

  std::size_t p;

  type* v;

public:

  ArrayOfAbsorptionLines() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfAbsorptionLines(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfAbsorptionLines() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfAbsorptionLines(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfAbsorptionLines& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfAgenda {

  using type = Group::ArrayOfAgenda;

  std::size_t p;

  type* v;

public:

  ArrayOfAgenda() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfAgenda(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfAgenda() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfAgenda(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfAgenda& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfAbsorptionLines {

  using type = Group::ArrayOfArrayOfAbsorptionLines;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfAbsorptionLines() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfAbsorptionLines(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfAbsorptionLines() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfAbsorptionLines(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfAbsorptionLines& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfGriddedField1 {

  using type = Group::ArrayOfArrayOfGriddedField1;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfGriddedField1() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfGriddedField1(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfGriddedField1() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfGriddedField1(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfGriddedField1& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfGriddedField2 {

  using type = Group::ArrayOfArrayOfGriddedField2;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfGriddedField2() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfGriddedField2(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfGriddedField2() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfGriddedField2(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfGriddedField2& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfGriddedField3 {

  using type = Group::ArrayOfArrayOfGriddedField3;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfGriddedField3() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfGriddedField3(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfGriddedField3() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfGriddedField3(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfGriddedField3& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfIndex {

  using type = Group::ArrayOfArrayOfIndex;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfIndex() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfIndex(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfIndex() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfIndex(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfIndex& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfMatrix {

  using type = Group::ArrayOfArrayOfMatrix;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfMatrix() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfMatrix(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfMatrix() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfMatrix(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfMatrix& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfPropagationMatrix {

  using type = Group::ArrayOfArrayOfPropagationMatrix;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfPropagationMatrix() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfPropagationMatrix(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfPropagationMatrix() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfPropagationMatrix(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfPropagationMatrix& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfRadiationVector {

  using type = Group::ArrayOfArrayOfRadiationVector;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfRadiationVector() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfRadiationVector(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfRadiationVector() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfRadiationVector(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfRadiationVector& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfScatteringMetaData {

  using type = Group::ArrayOfArrayOfScatteringMetaData;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfScatteringMetaData() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfScatteringMetaData(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfScatteringMetaData() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfScatteringMetaData(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfScatteringMetaData& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfSingleScatteringData {

  using type = Group::ArrayOfArrayOfSingleScatteringData;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfSingleScatteringData() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfSingleScatteringData(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfSingleScatteringData() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfSingleScatteringData(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfSingleScatteringData& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfSpeciesTag {

  using type = Group::ArrayOfArrayOfSpeciesTag;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfSpeciesTag() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfSpeciesTag(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfSpeciesTag() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfSpeciesTag(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfSpeciesTag& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfStokesVector {

  using type = Group::ArrayOfArrayOfStokesVector;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfStokesVector() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfStokesVector(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfStokesVector() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfStokesVector(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfStokesVector& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfString {

  using type = Group::ArrayOfArrayOfString;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfString() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfString(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfString() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfString(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfString& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfTensor3 {

  using type = Group::ArrayOfArrayOfTensor3;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfTensor3() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfTensor3(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfTensor3() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfTensor3(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfTensor3& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfTensor6 {

  using type = Group::ArrayOfArrayOfTensor6;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfTensor6() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfTensor6(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfTensor6() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfTensor6(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfTensor6& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfTime {

  using type = Group::ArrayOfArrayOfTime;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfTime() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfTime(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfTime() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfTime(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfTime& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfTransmissionMatrix {

  using type = Group::ArrayOfArrayOfTransmissionMatrix;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfTransmissionMatrix() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfTransmissionMatrix(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfTransmissionMatrix() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfTransmissionMatrix(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfTransmissionMatrix& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfArrayOfVector {

  using type = Group::ArrayOfArrayOfVector;

  std::size_t p;

  type* v;

public:

  ArrayOfArrayOfVector() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfArrayOfVector(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfArrayOfVector() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfArrayOfVector(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfArrayOfVector& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfCIARecord {

  using type = Group::ArrayOfCIARecord;

  std::size_t p;

  type* v;

public:

  ArrayOfCIARecord() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfCIARecord(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfCIARecord() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfCIARecord(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfCIARecord& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfGriddedField1 {

  using type = Group::ArrayOfGriddedField1;

  std::size_t p;

  type* v;

public:

  ArrayOfGriddedField1() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfGriddedField1(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfGriddedField1() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfGriddedField1(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfGriddedField1& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfGriddedField2 {

  using type = Group::ArrayOfGriddedField2;

  std::size_t p;

  type* v;

public:

  ArrayOfGriddedField2() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfGriddedField2(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfGriddedField2() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfGriddedField2(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfGriddedField2& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfGriddedField3 {

  using type = Group::ArrayOfGriddedField3;

  std::size_t p;

  type* v;

public:

  ArrayOfGriddedField3() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfGriddedField3(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfGriddedField3() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfGriddedField3(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfGriddedField3& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfGriddedField4 {

  using type = Group::ArrayOfGriddedField4;

  std::size_t p;

  type* v;

public:

  ArrayOfGriddedField4() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfGriddedField4(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfGriddedField4() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfGriddedField4(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfGriddedField4& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfIndex {

  using type = Group::ArrayOfIndex;

  std::size_t p;

  type* v;

public:

  ArrayOfIndex() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfIndex(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfIndex() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfIndex(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfIndex& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfMatrix {

  using type = Group::ArrayOfMatrix;

  std::size_t p;

  type* v;

public:

  ArrayOfMatrix() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfMatrix(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfMatrix() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfMatrix(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfMatrix& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfPpath {

  using type = Group::ArrayOfPpath;

  std::size_t p;

  type* v;

public:

  ArrayOfPpath() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfPpath(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfPpath() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfPpath(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfPpath& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfPropagationMatrix {

  using type = Group::ArrayOfPropagationMatrix;

  std::size_t p;

  type* v;

public:

  ArrayOfPropagationMatrix() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfPropagationMatrix(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfPropagationMatrix() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfPropagationMatrix(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfPropagationMatrix& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfQuantumIdentifier {

  using type = Group::ArrayOfQuantumIdentifier;

  std::size_t p;

  type* v;

public:

  ArrayOfQuantumIdentifier() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfQuantumIdentifier(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfQuantumIdentifier() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfQuantumIdentifier(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfQuantumIdentifier& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfRadiationVector {

  using type = Group::ArrayOfRadiationVector;

  std::size_t p;

  type* v;

public:

  ArrayOfRadiationVector() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfRadiationVector(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfRadiationVector() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfRadiationVector(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfRadiationVector& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfRetrievalQuantity {

  using type = Group::ArrayOfRetrievalQuantity;

  std::size_t p;

  type* v;

public:

  ArrayOfRetrievalQuantity() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfRetrievalQuantity(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfRetrievalQuantity() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfRetrievalQuantity(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfRetrievalQuantity& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfScatteringMetaData {

  using type = Group::ArrayOfScatteringMetaData;

  std::size_t p;

  type* v;

public:

  ArrayOfScatteringMetaData() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfScatteringMetaData(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfScatteringMetaData() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfScatteringMetaData(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfScatteringMetaData& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfSingleScatteringData {

  using type = Group::ArrayOfSingleScatteringData;

  std::size_t p;

  type* v;

public:

  ArrayOfSingleScatteringData() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfSingleScatteringData(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfSingleScatteringData() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfSingleScatteringData(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfSingleScatteringData& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfSparse {

  using type = Group::ArrayOfSparse;

  std::size_t p;

  type* v;

public:

  ArrayOfSparse() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfSparse(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfSparse() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfSparse(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfSparse& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfStokesVector {

  using type = Group::ArrayOfStokesVector;

  std::size_t p;

  type* v;

public:

  ArrayOfStokesVector() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfStokesVector(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfStokesVector() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfStokesVector(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfStokesVector& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfString {

  using type = Group::ArrayOfString;

  std::size_t p;

  type* v;

public:

  ArrayOfString() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfString(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfString() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfString(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfString& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfTelsemAtlas {

  using type = Group::ArrayOfTelsemAtlas;

  std::size_t p;

  type* v;

public:

  ArrayOfTelsemAtlas() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfTelsemAtlas(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfTelsemAtlas() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfTelsemAtlas(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfTelsemAtlas& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfTensor3 {

  using type = Group::ArrayOfTensor3;

  std::size_t p;

  type* v;

public:

  ArrayOfTensor3() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfTensor3(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfTensor3() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfTensor3(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfTensor3& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfTensor4 {

  using type = Group::ArrayOfTensor4;

  std::size_t p;

  type* v;

public:

  ArrayOfTensor4() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfTensor4(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfTensor4() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfTensor4(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfTensor4& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfTensor5 {

  using type = Group::ArrayOfTensor5;

  std::size_t p;

  type* v;

public:

  ArrayOfTensor5() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfTensor5(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfTensor5() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfTensor5(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfTensor5& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfTensor6 {

  using type = Group::ArrayOfTensor6;

  std::size_t p;

  type* v;

public:

  ArrayOfTensor6() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfTensor6(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfTensor6() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfTensor6(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfTensor6& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfTensor7 {

  using type = Group::ArrayOfTensor7;

  std::size_t p;

  type* v;

public:

  ArrayOfTensor7() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfTensor7(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfTensor7() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfTensor7(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfTensor7& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfTime {

  using type = Group::ArrayOfTime;

  std::size_t p;

  type* v;

public:

  ArrayOfTime() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfTime(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfTime() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfTime(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfTime& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfTransmissionMatrix {

  using type = Group::ArrayOfTransmissionMatrix;

  std::size_t p;

  type* v;

public:

  ArrayOfTransmissionMatrix() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfTransmissionMatrix(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfTransmissionMatrix() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfTransmissionMatrix(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfTransmissionMatrix& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfVector {

  using type = Group::ArrayOfVector;

  std::size_t p;

  type* v;

public:

  ArrayOfVector() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfVector(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfVector() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfVector(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfVector& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ArrayOfXsecRecord {

  using type = Group::ArrayOfXsecRecord;

  std::size_t p;

  type* v;

public:

  ArrayOfXsecRecord() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ArrayOfXsecRecord(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ArrayOfXsecRecord() noexcept {if (islast() and not isnull()) delete v;}

  ArrayOfXsecRecord(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ArrayOfXsecRecord& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class CIARecord {

  using type = Group::CIARecord;

  std::size_t p;

  type* v;

public:

  CIARecord() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  CIARecord(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~CIARecord() noexcept {if (islast() and not isnull()) delete v;}

  CIARecord(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  CIARecord& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class CovarianceMatrix {

  using type = Group::CovarianceMatrix;

  std::size_t p;

  type* v;

public:

  CovarianceMatrix() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  CovarianceMatrix(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~CovarianceMatrix() noexcept {if (islast() and not isnull()) delete v;}

  CovarianceMatrix(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  CovarianceMatrix& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class EnergyLevelMap {

  using type = Group::EnergyLevelMap;

  std::size_t p;

  type* v;

public:

  EnergyLevelMap() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  EnergyLevelMap(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~EnergyLevelMap() noexcept {if (islast() and not isnull()) delete v;}

  EnergyLevelMap(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  EnergyLevelMap& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class GasAbsLookup {

  using type = Group::GasAbsLookup;

  std::size_t p;

  type* v;

public:

  GasAbsLookup() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  GasAbsLookup(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~GasAbsLookup() noexcept {if (islast() and not isnull()) delete v;}

  GasAbsLookup(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  GasAbsLookup& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class GridPos {

  using type = Group::GridPos;

  std::size_t p;

  type* v;

public:

  GridPos() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  GridPos(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~GridPos() noexcept {if (islast() and not isnull()) delete v;}

  GridPos(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  GridPos& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class GriddedField1 {

  using type = Group::GriddedField1;

  std::size_t p;

  type* v;

public:

  GriddedField1() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  GriddedField1(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~GriddedField1() noexcept {if (islast() and not isnull()) delete v;}

  GriddedField1(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  GriddedField1& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class GriddedField2 {

  using type = Group::GriddedField2;

  std::size_t p;

  type* v;

public:

  GriddedField2() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  GriddedField2(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~GriddedField2() noexcept {if (islast() and not isnull()) delete v;}

  GriddedField2(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  GriddedField2& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class GriddedField3 {

  using type = Group::GriddedField3;

  std::size_t p;

  type* v;

public:

  GriddedField3() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  GriddedField3(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~GriddedField3() noexcept {if (islast() and not isnull()) delete v;}

  GriddedField3(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  GriddedField3& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class GriddedField4 {

  using type = Group::GriddedField4;

  std::size_t p;

  type* v;

public:

  GriddedField4() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  GriddedField4(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~GriddedField4() noexcept {if (islast() and not isnull()) delete v;}

  GriddedField4(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  GriddedField4& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class GriddedField5 {

  using type = Group::GriddedField5;

  std::size_t p;

  type* v;

public:

  GriddedField5() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  GriddedField5(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~GriddedField5() noexcept {if (islast() and not isnull()) delete v;}

  GriddedField5(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  GriddedField5& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class GriddedField6 {

  using type = Group::GriddedField6;

  std::size_t p;

  type* v;

public:

  GriddedField6() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  GriddedField6(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~GriddedField6() noexcept {if (islast() and not isnull()) delete v;}

  GriddedField6(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  GriddedField6& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class HitranRelaxationMatrixData {

  using type = Group::HitranRelaxationMatrixData;

  std::size_t p;

  type* v;

public:

  HitranRelaxationMatrixData() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  HitranRelaxationMatrixData(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~HitranRelaxationMatrixData() noexcept {if (islast() and not isnull()) delete v;}

  HitranRelaxationMatrixData(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  HitranRelaxationMatrixData& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Index {

  using type = Group::Index;

  std::size_t p;

  type* v;

public:

  Index() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Index(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Index() noexcept {if (islast() and not isnull()) delete v;}

  Index(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Index& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class MCAntenna {

  using type = Group::MCAntenna;

  std::size_t p;

  type* v;

public:

  MCAntenna() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  MCAntenna(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~MCAntenna() noexcept {if (islast() and not isnull()) delete v;}

  MCAntenna(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  MCAntenna& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Matrix {

  using type = Group::Matrix;

  std::size_t p;

  type* v;

public:

  Matrix() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Matrix(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Matrix() noexcept {if (islast() and not isnull()) delete v;}

  Matrix(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Matrix& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Numeric {

  using type = Group::Numeric;

  std::size_t p;

  type* v;

public:

  Numeric() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Numeric(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Numeric() noexcept {if (islast() and not isnull()) delete v;}

  Numeric(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Numeric& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Ppath {

  using type = Group::Ppath;

  std::size_t p;

  type* v;

public:

  Ppath() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Ppath(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Ppath() noexcept {if (islast() and not isnull()) delete v;}

  Ppath(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Ppath& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class PropagationMatrix {

  using type = Group::PropagationMatrix;

  std::size_t p;

  type* v;

public:

  PropagationMatrix() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  PropagationMatrix(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~PropagationMatrix() noexcept {if (islast() and not isnull()) delete v;}

  PropagationMatrix(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  PropagationMatrix& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class QuantumIdentifier {

  using type = Group::QuantumIdentifier;

  std::size_t p;

  type* v;

public:

  QuantumIdentifier() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  QuantumIdentifier(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~QuantumIdentifier() noexcept {if (islast() and not isnull()) delete v;}

  QuantumIdentifier(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  QuantumIdentifier& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class RadiationVector {

  using type = Group::RadiationVector;

  std::size_t p;

  type* v;

public:

  RadiationVector() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  RadiationVector(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~RadiationVector() noexcept {if (islast() and not isnull()) delete v;}

  RadiationVector(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  RadiationVector& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Rational {

  using type = Group::Rational;

  std::size_t p;

  type* v;

public:

  Rational() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Rational(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Rational() noexcept {if (islast() and not isnull()) delete v;}

  Rational(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Rational& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class ScatteringMetaData {

  using type = Group::ScatteringMetaData;

  std::size_t p;

  type* v;

public:

  ScatteringMetaData() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  ScatteringMetaData(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~ScatteringMetaData() noexcept {if (islast() and not isnull()) delete v;}

  ScatteringMetaData(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  ScatteringMetaData& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class SingleScatteringData {

  using type = Group::SingleScatteringData;

  std::size_t p;

  type* v;

public:

  SingleScatteringData() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  SingleScatteringData(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~SingleScatteringData() noexcept {if (islast() and not isnull()) delete v;}

  SingleScatteringData(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  SingleScatteringData& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Sparse {

  using type = Group::Sparse;

  std::size_t p;

  type* v;

public:

  Sparse() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Sparse(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Sparse() noexcept {if (islast() and not isnull()) delete v;}

  Sparse(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Sparse& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class SpeciesAuxData {

  using type = Group::SpeciesAuxData;

  std::size_t p;

  type* v;

public:

  SpeciesAuxData() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  SpeciesAuxData(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~SpeciesAuxData() noexcept {if (islast() and not isnull()) delete v;}

  SpeciesAuxData(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  SpeciesAuxData& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class StokesVector {

  using type = Group::StokesVector;

  std::size_t p;

  type* v;

public:

  StokesVector() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  StokesVector(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~StokesVector() noexcept {if (islast() and not isnull()) delete v;}

  StokesVector(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  StokesVector& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class String {

  using type = Group::String;

  std::size_t p;

  type* v;

public:

  String() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  String(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~String() noexcept {if (islast() and not isnull()) delete v;}

  String(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  String& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class TelsemAtlas {

  using type = Group::TelsemAtlas;

  std::size_t p;

  type* v;

public:

  TelsemAtlas() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  TelsemAtlas(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~TelsemAtlas() noexcept {if (islast() and not isnull()) delete v;}

  TelsemAtlas(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  TelsemAtlas& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Tensor3 {

  using type = Group::Tensor3;

  std::size_t p;

  type* v;

public:

  Tensor3() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Tensor3(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Tensor3() noexcept {if (islast() and not isnull()) delete v;}

  Tensor3(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Tensor3& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Tensor4 {

  using type = Group::Tensor4;

  std::size_t p;

  type* v;

public:

  Tensor4() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Tensor4(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Tensor4() noexcept {if (islast() and not isnull()) delete v;}

  Tensor4(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Tensor4& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Tensor5 {

  using type = Group::Tensor5;

  std::size_t p;

  type* v;

public:

  Tensor5() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Tensor5(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Tensor5() noexcept {if (islast() and not isnull()) delete v;}

  Tensor5(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Tensor5& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Tensor6 {

  using type = Group::Tensor6;

  std::size_t p;

  type* v;

public:

  Tensor6() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Tensor6(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Tensor6() noexcept {if (islast() and not isnull()) delete v;}

  Tensor6(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Tensor6& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Tensor7 {

  using type = Group::Tensor7;

  std::size_t p;

  type* v;

public:

  Tensor7() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Tensor7(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Tensor7() noexcept {if (islast() and not isnull()) delete v;}

  Tensor7(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Tensor7& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class TessemNN {

  using type = Group::TessemNN;

  std::size_t p;

  type* v;

public:

  TessemNN() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  TessemNN(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~TessemNN() noexcept {if (islast() and not isnull()) delete v;}

  TessemNN(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  TessemNN& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Time {

  using type = Group::Time;

  std::size_t p;

  type* v;

public:

  Time() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Time(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Time() noexcept {if (islast() and not isnull()) delete v;}

  Time(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Time& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Timer {

  using type = Group::Timer;

  std::size_t p;

  type* v;

public:

  Timer() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Timer(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Timer() noexcept {if (islast() and not isnull()) delete v;}

  Timer(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Timer& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class TransmissionMatrix {

  using type = Group::TransmissionMatrix;

  std::size_t p;

  type* v;

public:

  TransmissionMatrix() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  TransmissionMatrix(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~TransmissionMatrix() noexcept {if (islast() and not isnull()) delete v;}

  TransmissionMatrix(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  TransmissionMatrix& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Vector {

  using type = Group::Vector;

  std::size_t p;

  type* v;

public:

  Vector() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Vector(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Vector() noexcept {if (islast() and not isnull()) delete v;}

  Vector(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Vector& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


class Verbosity {

  using type = Group::Verbosity;

  std::size_t p;

  type* v;

public:

  Verbosity() noexcept : p(std::numeric_limits<std::size_t>::max()), v(nullptr) {}

  Verbosity(std::size_t i, void * x) noexcept : p(i), v(static_cast<type *>(x)) {}

  ~Verbosity() noexcept {if (islast() and not isnull()) delete v;}

  Verbosity(const type& val) noexcept : p(std::numeric_limits<std::size_t>::max()), v(new type(val)) {}

  type& value() noexcept {return *v;}

  const type& value() const noexcept {return *v;}

  Verbosity& operator=(const type& t) noexcept {value() = t; return *this;}

  std::size_t pos() const noexcept {return p;}

  bool isnull() const noexcept {return v == nullptr;}

  bool islast() const noexcept {return p == std::numeric_limits<std::size_t>::max();}

  const Group::String& name() const noexcept {return Workspace::wsv_data[p].Name();}

};


[[nodiscard]] inline Vector aa_grid(Workspace& ws) noexcept { return {0, ws[0]}; }


[[nodiscard]] inline Index aa_index(Workspace& ws) noexcept { return {1, ws[1]}; }


[[nodiscard]] inline ArrayOfCIARecord abs_cia_data(Workspace& ws) noexcept { return {2, ws[2]}; }


[[nodiscard]] inline Matrix abs_coef(Workspace& ws) noexcept { return {3, ws[3]}; }


[[nodiscard]] inline ArrayOfMatrix abs_coef_per_species(Workspace& ws) noexcept { return {4, ws[4]}; }


[[nodiscard]] inline ArrayOfString abs_cont_models(Workspace& ws) noexcept { return {5, ws[5]}; }


[[nodiscard]] inline ArrayOfString abs_cont_names(Workspace& ws) noexcept { return {6, ws[6]}; }


[[nodiscard]] inline ArrayOfVector abs_cont_parameters(Workspace& ws) noexcept { return {7, ws[7]}; }


[[nodiscard]] inline Index abs_f_interp_order(Workspace& ws) noexcept { return {8, ws[8]}; }


[[nodiscard]] inline HitranRelaxationMatrixData abs_hitran_relmat_data(Workspace& ws) noexcept { return {9, ws[9]}; }


[[nodiscard]] inline ArrayOfAbsorptionLines abs_lines(Workspace& ws) noexcept { return {10, ws[10]}; }


[[nodiscard]] inline ArrayOfArrayOfAbsorptionLines abs_lines_per_species(Workspace& ws) noexcept { return {11, ws[11]}; }


[[nodiscard]] inline GasAbsLookup abs_lookup(Workspace& ws) noexcept { return {12, ws[12]}; }


[[nodiscard]] inline Index abs_lookup_is_adapted(Workspace& ws) noexcept { return {19, ws[19]}; }


[[nodiscard]] inline ArrayOfArrayOfSpeciesTag abs_nls(Workspace& ws) noexcept { return {13, ws[13]}; }


[[nodiscard]] inline Index abs_nls_interp_order(Workspace& ws) noexcept { return {15, ws[15]}; }


[[nodiscard]] inline Vector abs_nls_pert(Workspace& ws) noexcept { return {14, ws[14]}; }


[[nodiscard]] inline EnergyLevelMap abs_nlte(Workspace& ws) noexcept { return {24, ws[24]}; }


[[nodiscard]] inline Vector abs_p(Workspace& ws) noexcept { return {20, ws[20]}; }


[[nodiscard]] inline Index abs_p_interp_order(Workspace& ws) noexcept { return {16, ws[16]}; }


[[nodiscard]] inline ArrayOfArrayOfSpeciesTag abs_species(Workspace& ws) noexcept { return {21, ws[21]}; }


[[nodiscard]] inline ArrayOfIndex abs_species_active(Workspace& ws) noexcept { return {22, ws[22]}; }


[[nodiscard]] inline Vector abs_t(Workspace& ws) noexcept { return {23, ws[23]}; }


[[nodiscard]] inline Index abs_t_interp_order(Workspace& ws) noexcept { return {18, ws[18]}; }


[[nodiscard]] inline Vector abs_t_pert(Workspace& ws) noexcept { return {17, ws[17]}; }


[[nodiscard]] inline StokesVector abs_vec(Workspace& ws) noexcept { return {25, ws[25]}; }


[[nodiscard]] inline ArrayOfStokesVector abs_vec_spt(Workspace& ws) noexcept { return {26, ws[26]}; }


[[nodiscard]] inline Matrix abs_vmrs(Workspace& ws) noexcept { return {27, ws[27]}; }


[[nodiscard]] inline Agenda abs_xsec_agenda(Workspace& ws) noexcept { return {29, ws[29]}; }


[[nodiscard]] inline Index abs_xsec_agenda_checked(Workspace& ws) noexcept { return {28, ws[28]}; }


[[nodiscard]] inline ArrayOfMatrix abs_xsec_per_species(Workspace& ws) noexcept { return {30, ws[30]}; }


[[nodiscard]] inline Index agenda_array_index(Workspace& ws) noexcept { return {31, ws[31]}; }


[[nodiscard]] inline Index antenna_dim(Workspace& ws) noexcept { return {32, ws[32]}; }


[[nodiscard]] inline Matrix antenna_dlos(Workspace& ws) noexcept { return {33, ws[33]}; }


[[nodiscard]] inline GriddedField4 antenna_response(Workspace& ws) noexcept { return {34, ws[34]}; }


[[nodiscard]] inline GriddedField4 atm_fields_compact(Workspace& ws) noexcept { return {38, ws[38]}; }


[[nodiscard]] inline Index atmfields_checked(Workspace& ws) noexcept { return {36, ws[36]}; }


[[nodiscard]] inline Index atmgeom_checked(Workspace& ws) noexcept { return {37, ws[37]}; }


[[nodiscard]] inline Index atmosphere_dim(Workspace& ws) noexcept { return {35, ws[35]}; }


[[nodiscard]] inline Matrix avk(Workspace& ws) noexcept { return {39, ws[39]}; }


[[nodiscard]] inline ArrayOfGriddedField1 backend_channel_response(Workspace& ws) noexcept { return {40, ws[40]}; }


[[nodiscard]] inline ArrayOfArrayOfGriddedField1 backend_channel_response_multi(Workspace& ws) noexcept { return {41, ws[41]}; }


[[nodiscard]] inline ArrayOfQuantumIdentifier band_identifiers(Workspace& ws) noexcept { return {43, ws[43]}; }


[[nodiscard]] inline ArrayOfGriddedField4 batch_atm_fields_compact(Workspace& ws) noexcept { return {42, ws[42]}; }


[[nodiscard]] inline ArrayOfArrayOfIndex batch_cloudbox_limits(Workspace& ws) noexcept { return {44, ws[44]}; }


[[nodiscard]] inline ArrayOfTensor4 batch_pnd_fields(Workspace& ws) noexcept { return {45, ws[45]}; }


[[nodiscard]] inline ArrayOfArrayOfIndex channel2fgrid_indexes(Workspace& ws) noexcept { return {46, ws[46]}; }


[[nodiscard]] inline ArrayOfVector channel2fgrid_weights(Workspace& ws) noexcept { return {47, ws[47]}; }


[[nodiscard]] inline Index cloudbox_checked(Workspace& ws) noexcept { return {48, ws[48]}; }


[[nodiscard]] inline Tensor7 cloudbox_field(Workspace& ws) noexcept { return {49, ws[49]}; }


[[nodiscard]] inline Tensor6 cloudbox_field_mono(Workspace& ws) noexcept { return {50, ws[50]}; }


[[nodiscard]] inline Tensor6 cloudbox_field_mono_old(Workspace& ws) noexcept { return {51, ws[51]}; }


[[nodiscard]] inline ArrayOfIndex cloudbox_limits(Workspace& ws) noexcept { return {52, ws[52]}; }


[[nodiscard]] inline Index cloudbox_on(Workspace& ws) noexcept { return {53, ws[53]}; }


[[nodiscard]] inline ArrayOfArrayOfGriddedField1 collision_coefficients(Workspace& ws) noexcept { return {182, ws[182]}; }


[[nodiscard]] inline ArrayOfQuantumIdentifier collision_line_identifiers(Workspace& ws) noexcept { return {181, ws[181]}; }


[[nodiscard]] inline GriddedField3 complex_refr_index(Workspace& ws) noexcept { return {54, ws[54]}; }


[[nodiscard]] inline ArrayOfIndex counts(Workspace& ws) noexcept { return {55, ws[55]}; }


[[nodiscard]] inline Sparse covmat_block(Workspace& ws) noexcept { return {56, ws[56]}; }


[[nodiscard]] inline Sparse covmat_inv_block(Workspace& ws) noexcept { return {57, ws[57]}; }


[[nodiscard]] inline CovarianceMatrix covmat_se(Workspace& ws) noexcept { return {58, ws[58]}; }


[[nodiscard]] inline ArrayOfMatrix covmat_sepsbatch(Workspace& ws) noexcept { return {59, ws[59]}; }


[[nodiscard]] inline Matrix covmat_so(Workspace& ws) noexcept { return {61, ws[61]}; }


[[nodiscard]] inline Matrix covmat_ss(Workspace& ws) noexcept { return {62, ws[62]}; }


[[nodiscard]] inline CovarianceMatrix covmat_sx(Workspace& ws) noexcept { return {60, ws[60]}; }


[[nodiscard]] inline ArrayOfMatrix dabs_coef_dx(Workspace& ws) noexcept { return {63, ws[63]}; }


[[nodiscard]] inline ArrayOfArrayOfMatrix dabs_xsec_per_species_dx(Workspace& ws) noexcept { return {64, ws[64]}; }


[[nodiscard]] inline ArrayOfTensor3 diy_dx(Workspace& ws) noexcept { return {72, ws[72]}; }


[[nodiscard]] inline ArrayOfStokesVector dnlte_dx_source(Workspace& ws) noexcept { return {78, ws[78]}; }


[[nodiscard]] inline Agenda dobatch_calc_agenda(Workspace& ws) noexcept { return {65, ws[65]}; }


[[nodiscard]] inline ArrayOfTensor7 dobatch_cloudbox_field(Workspace& ws) noexcept { return {66, ws[66]}; }


[[nodiscard]] inline ArrayOfTensor4 dobatch_irradiance_field(Workspace& ws) noexcept { return {68, ws[68]}; }


[[nodiscard]] inline ArrayOfTensor5 dobatch_radiance_field(Workspace& ws) noexcept { return {67, ws[67]}; }


[[nodiscard]] inline ArrayOfTensor5 dobatch_spectral_irradiance_field(Workspace& ws) noexcept { return {69, ws[69]}; }


[[nodiscard]] inline Index doit_conv_flag(Workspace& ws) noexcept { return {80, ws[80]}; }


[[nodiscard]] inline Agenda doit_conv_test_agenda(Workspace& ws) noexcept { return {81, ws[81]}; }


[[nodiscard]] inline Index doit_is_initialized(Workspace& ws) noexcept { return {82, ws[82]}; }


[[nodiscard]] inline Index doit_iteration_counter(Workspace& ws) noexcept { return {83, ws[83]}; }


[[nodiscard]] inline Agenda doit_mono_agenda(Workspace& ws) noexcept { return {84, ws[84]}; }


[[nodiscard]] inline Agenda doit_rte_agenda(Workspace& ws) noexcept { return {85, ws[85]}; }


[[nodiscard]] inline Tensor6 doit_scat_field(Workspace& ws) noexcept { return {87, ws[87]}; }


[[nodiscard]] inline Agenda doit_scat_field_agenda(Workspace& ws) noexcept { return {86, ws[86]}; }


[[nodiscard]] inline Vector doit_za_grid_opt(Workspace& ws) noexcept { return {88, ws[88]}; }


[[nodiscard]] inline Index doit_za_grid_size(Workspace& ws) noexcept { return {89, ws[89]}; }


[[nodiscard]] inline Index doit_za_interp(Workspace& ws) noexcept { return {90, ws[90]}; }


[[nodiscard]] inline Tensor3 dpnd_data_dx(Workspace& ws) noexcept { return {73, ws[73]}; }


[[nodiscard]] inline ArrayOfString dpnd_data_dx_names(Workspace& ws) noexcept { return {74, ws[74]}; }


[[nodiscard]] inline ArrayOfTensor4 dpnd_field_dx(Workspace& ws) noexcept { return {75, ws[75]}; }


[[nodiscard]] inline ArrayOfPropagationMatrix dpropmat_clearsky_dx(Workspace& ws) noexcept { return {76, ws[76]}; }


[[nodiscard]] inline Tensor3 dpsd_data_dx(Workspace& ws) noexcept { return {77, ws[77]}; }


[[nodiscard]] inline ArrayOfMatrix dsrc_coef_dx(Workspace& ws) noexcept { return {70, ws[70]}; }


[[nodiscard]] inline ArrayOfArrayOfMatrix dsrc_xsec_per_species_dx(Workspace& ws) noexcept { return {71, ws[71]}; }


[[nodiscard]] inline ArrayOfMatrix dsurface_emission_dx(Workspace& ws) noexcept { return {91, ws[91]}; }


[[nodiscard]] inline ArrayOfString dsurface_names(Workspace& ws) noexcept { return {92, ws[92]}; }


[[nodiscard]] inline ArrayOfTensor4 dsurface_rmatrix_dx(Workspace& ws) noexcept { return {93, ws[93]}; }


[[nodiscard]] inline Matrix dxdy(Workspace& ws) noexcept { return {94, ws[94]}; }


[[nodiscard]] inline PropagationMatrix ext_mat(Workspace& ws) noexcept { return {95, ws[95]}; }


[[nodiscard]] inline ArrayOfPropagationMatrix ext_mat_spt(Workspace& ws) noexcept { return {96, ws[96]}; }


[[nodiscard]] inline Vector f_backend(Workspace& ws) noexcept { return {102, ws[102]}; }


[[nodiscard]] inline ArrayOfVector f_backend_multi(Workspace& ws) noexcept { return {103, ws[103]}; }


[[nodiscard]] inline Vector f_grid(Workspace& ws) noexcept { return {104, ws[104]}; }


[[nodiscard]] inline Index f_index(Workspace& ws) noexcept { return {105, ws[105]}; }


[[nodiscard]] inline Index file_index(Workspace& ws) noexcept { return {97, ws[97]}; }


[[nodiscard]] inline Agenda forloop_agenda(Workspace& ws) noexcept { return {98, ws[98]}; }


[[nodiscard]] inline Index forloop_index(Workspace& ws) noexcept { return {99, ws[99]}; }


[[nodiscard]] inline Vector fos_iyin_za_angles(Workspace& ws) noexcept { return {100, ws[100]}; }


[[nodiscard]] inline Matrix fos_scatint_angles(Workspace& ws) noexcept { return {101, ws[101]}; }


[[nodiscard]] inline Numeric g0(Workspace& ws) noexcept { return {107, ws[107]}; }


[[nodiscard]] inline Agenda g0_agenda(Workspace& ws) noexcept { return {108, ws[108]}; }


[[nodiscard]] inline Vector geo_pos(Workspace& ws) noexcept { return {106, ws[106]}; }


[[nodiscard]] inline Agenda geo_pos_agenda(Workspace& ws) noexcept { return {109, ws[109]}; }


[[nodiscard]] inline Tensor3 heating_rates(Workspace& ws) noexcept { return {110, ws[110]}; }


[[nodiscard]] inline ArrayOfXsecRecord hitran_xsec_data(Workspace& ws) noexcept { return {111, ws[111]}; }


[[nodiscard]] inline ArrayOfIndex instrument_pol(Workspace& ws) noexcept { return {112, ws[112]}; }


[[nodiscard]] inline ArrayOfArrayOfIndex instrument_pol_array(Workspace& ws) noexcept { return {113, ws[113]}; }


[[nodiscard]] inline Agenda inversion_iterate_agenda(Workspace& ws) noexcept { return {115, ws[115]}; }


[[nodiscard]] inline Index inversion_iteration_counter(Workspace& ws) noexcept { return {114, ws[114]}; }


[[nodiscard]] inline Tensor4 irradiance_field(Workspace& ws) noexcept { return {116, ws[116]}; }


[[nodiscard]] inline SpeciesAuxData isotopologue_ratios(Workspace& ws) noexcept { return {117, ws[117]}; }


[[nodiscard]] inline Matrix iy(Workspace& ws) noexcept { return {118, ws[118]}; }


[[nodiscard]] inline Index iy_agenda_call1(Workspace& ws) noexcept { return {120, ws[120]}; }


[[nodiscard]] inline ArrayOfMatrix iy_aux(Workspace& ws) noexcept { return {121, ws[121]}; }


[[nodiscard]] inline ArrayOfString iy_aux_vars(Workspace& ws) noexcept { return {122, ws[122]}; }


[[nodiscard]] inline Agenda iy_cloudbox_agenda(Workspace& ws) noexcept { return {123, ws[123]}; }


[[nodiscard]] inline Index iy_id(Workspace& ws) noexcept { return {125, ws[125]}; }


[[nodiscard]] inline Agenda iy_independent_beam_approx_agenda(Workspace& ws) noexcept { return {124, ws[124]}; }


[[nodiscard]] inline Agenda iy_loop_freqs_agenda(Workspace& ws) noexcept { return {126, ws[126]}; }


[[nodiscard]] inline Agenda iy_main_agenda(Workspace& ws) noexcept { return {127, ws[127]}; }


[[nodiscard]] inline Agenda iy_space_agenda(Workspace& ws) noexcept { return {128, ws[128]}; }


[[nodiscard]] inline Agenda iy_surface_agenda(Workspace& ws) noexcept { return {129, ws[129]}; }


[[nodiscard]] inline ArrayOfAgenda iy_surface_agenda_array(Workspace& ws) noexcept { return {130, ws[130]}; }


[[nodiscard]] inline Tensor3 iy_transmission(Workspace& ws) noexcept { return {131, ws[131]}; }


[[nodiscard]] inline Agenda iy_transmitter_agenda(Workspace& ws) noexcept { return {132, ws[132]}; }


[[nodiscard]] inline String iy_unit(Workspace& ws) noexcept { return {133, ws[133]}; }


[[nodiscard]] inline Vector iyb(Workspace& ws) noexcept { return {119, ws[119]}; }


[[nodiscard]] inline Matrix jacobian(Workspace& ws) noexcept { return {134, ws[134]}; }


[[nodiscard]] inline Agenda jacobian_agenda(Workspace& ws) noexcept { return {135, ws[135]}; }


[[nodiscard]] inline Index jacobian_do(Workspace& ws) noexcept { return {136, ws[136]}; }


[[nodiscard]] inline ArrayOfRetrievalQuantity jacobian_quantities(Workspace& ws) noexcept { return {137, ws[137]}; }


[[nodiscard]] inline Numeric lat(Workspace& ws) noexcept { return {138, ws[138]}; }


[[nodiscard]] inline Vector lat_grid(Workspace& ws) noexcept { return {139, ws[139]}; }


[[nodiscard]] inline Vector lat_true(Workspace& ws) noexcept { return {140, ws[140]}; }


[[nodiscard]] inline Index lbl_checked(Workspace& ws) noexcept { return {141, ws[141]}; }


[[nodiscard]] inline Matrix line_irradiance(Workspace& ws) noexcept { return {142, ws[142]}; }


[[nodiscard]] inline Tensor3 line_transmission(Workspace& ws) noexcept { return {143, ws[143]}; }


[[nodiscard]] inline Vector lm_ga_history(Workspace& ws) noexcept { return {177, ws[177]}; }


[[nodiscard]] inline Numeric lo(Workspace& ws) noexcept { return {144, ws[144]}; }


[[nodiscard]] inline Vector lo_multi(Workspace& ws) noexcept { return {145, ws[145]}; }


[[nodiscard]] inline Numeric lon(Workspace& ws) noexcept { return {146, ws[146]}; }


[[nodiscard]] inline Vector lon_grid(Workspace& ws) noexcept { return {147, ws[147]}; }


[[nodiscard]] inline Vector lon_true(Workspace& ws) noexcept { return {148, ws[148]}; }


[[nodiscard]] inline Tensor3 mag_u_field(Workspace& ws) noexcept { return {149, ws[149]}; }


[[nodiscard]] inline GriddedField3 mag_u_field_raw(Workspace& ws) noexcept { return {150, ws[150]}; }


[[nodiscard]] inline Tensor3 mag_v_field(Workspace& ws) noexcept { return {151, ws[151]}; }


[[nodiscard]] inline GriddedField3 mag_v_field_raw(Workspace& ws) noexcept { return {152, ws[152]}; }


[[nodiscard]] inline Tensor3 mag_w_field(Workspace& ws) noexcept { return {153, ws[153]}; }


[[nodiscard]] inline GriddedField3 mag_w_field_raw(Workspace& ws) noexcept { return {154, ws[154]}; }


[[nodiscard]] inline Agenda main_agenda(Workspace& ws) noexcept { return {155, ws[155]}; }


[[nodiscard]] inline Matrix mblock_dlos_grid(Workspace& ws) noexcept { return {156, ws[156]}; }


[[nodiscard]] inline Index mblock_index(Workspace& ws) noexcept { return {157, ws[157]}; }


[[nodiscard]] inline MCAntenna mc_antenna(Workspace& ws) noexcept { return {158, ws[158]}; }


[[nodiscard]] inline Vector mc_error(Workspace& ws) noexcept { return {159, ws[159]}; }


[[nodiscard]] inline Index mc_iteration_count(Workspace& ws) noexcept { return {160, ws[160]}; }


[[nodiscard]] inline Index mc_max_iter(Workspace& ws) noexcept { return {161, ws[161]}; }


[[nodiscard]] inline Index mc_max_scatorder(Workspace& ws) noexcept { return {162, ws[162]}; }


[[nodiscard]] inline Index mc_max_time(Workspace& ws) noexcept { return {163, ws[163]}; }


[[nodiscard]] inline Index mc_min_iter(Workspace& ws) noexcept { return {164, ws[164]}; }


[[nodiscard]] inline Tensor3 mc_points(Workspace& ws) noexcept { return {165, ws[165]}; }


[[nodiscard]] inline ArrayOfIndex mc_scat_order(Workspace& ws) noexcept { return {166, ws[166]}; }


[[nodiscard]] inline Index mc_seed(Workspace& ws) noexcept { return {168, ws[168]}; }


[[nodiscard]] inline ArrayOfIndex mc_source_domain(Workspace& ws) noexcept { return {167, ws[167]}; }


[[nodiscard]] inline Numeric mc_std_err(Workspace& ws) noexcept { return {169, ws[169]}; }


[[nodiscard]] inline Numeric mc_taustep_limit(Workspace& ws) noexcept { return {171, ws[171]}; }


[[nodiscard]] inline Vector mc_y_tx(Workspace& ws) noexcept { return {170, ws[170]}; }


[[nodiscard]] inline Matrix met_amsu_data(Workspace& ws) noexcept { return {172, ws[172]}; }


[[nodiscard]] inline Vector met_mm_antenna(Workspace& ws) noexcept { return {173, ws[173]}; }


[[nodiscard]] inline Matrix met_mm_backend(Workspace& ws) noexcept { return {174, ws[174]}; }


[[nodiscard]] inline ArrayOfString met_mm_polarisation(Workspace& ws) noexcept { return {175, ws[175]}; }


[[nodiscard]] inline Agenda met_profile_calc_agenda(Workspace& ws) noexcept { return {176, ws[176]}; }


[[nodiscard]] inline Numeric molarmass_dry_air(Workspace& ws) noexcept { return {178, ws[178]}; }


[[nodiscard]] inline Index nbooks(Workspace& ws) noexcept { return {187, ws[187]}; }


[[nodiscard]] inline Index ncols(Workspace& ws) noexcept { return {184, ws[184]}; }


[[nodiscard]] inline Index nelem(Workspace& ws) noexcept { return {183, ws[183]}; }


[[nodiscard]] inline Index nlibraries(Workspace& ws) noexcept { return {190, ws[190]}; }


[[nodiscard]] inline Index nlte_do(Workspace& ws) noexcept { return {191, ws[191]}; }


[[nodiscard]] inline ArrayOfStokesVector nlte_dsource_dx(Workspace& ws) noexcept { return {79, ws[79]}; }


[[nodiscard]] inline EnergyLevelMap nlte_field(Workspace& ws) noexcept { return {339, ws[339]}; }


[[nodiscard]] inline ArrayOfGriddedField3 nlte_field_raw(Workspace& ws) noexcept { return {341, ws[341]}; }


[[nodiscard]] inline ArrayOfQuantumIdentifier nlte_level_identifiers(Workspace& ws) noexcept { return {179, ws[179]}; }


[[nodiscard]] inline ArrayOfStokesVector nlte_source(Workspace& ws) noexcept { return {192, ws[192]}; }


[[nodiscard]] inline Tensor6 nlte_source_field(Workspace& ws) noexcept { return {193, ws[193]}; }


[[nodiscard]] inline Vector nlte_vibrational_energies(Workspace& ws) noexcept { return {180, ws[180]}; }


[[nodiscard]] inline Index npages(Workspace& ws) noexcept { return {186, ws[186]}; }


[[nodiscard]] inline Index nrows(Workspace& ws) noexcept { return {185, ws[185]}; }


[[nodiscard]] inline Index nshelves(Workspace& ws) noexcept { return {188, ws[188]}; }


[[nodiscard]] inline Index nvitrines(Workspace& ws) noexcept { return {189, ws[189]}; }


[[nodiscard]] inline Vector oem_diagnostics(Workspace& ws) noexcept { return {194, ws[194]}; }


[[nodiscard]] inline ArrayOfString oem_errors(Workspace& ws) noexcept { return {195, ws[195]}; }


[[nodiscard]] inline String output_file_format(Workspace& ws) noexcept { return {196, ws[196]}; }


[[nodiscard]] inline Vector p_grid(Workspace& ws) noexcept { return {242, ws[242]}; }


[[nodiscard]] inline Vector p_grid_orig(Workspace& ws) noexcept { return {243, ws[243]}; }


[[nodiscard]] inline Numeric p_hse(Workspace& ws) noexcept { return {244, ws[244]}; }


[[nodiscard]] inline Tensor4 particle_bulkprop_field(Workspace& ws) noexcept { return {197, ws[197]}; }


[[nodiscard]] inline ArrayOfString particle_bulkprop_names(Workspace& ws) noexcept { return {198, ws[198]}; }


[[nodiscard]] inline Matrix particle_masses(Workspace& ws) noexcept { return {199, ws[199]}; }


[[nodiscard]] inline SpeciesAuxData partition_functions(Workspace& ws) noexcept { return {200, ws[200]}; }


[[nodiscard]] inline Tensor4 pha_mat(Workspace& ws) noexcept { return {201, ws[201]}; }


[[nodiscard]] inline Tensor7 pha_mat_doit(Workspace& ws) noexcept { return {202, ws[202]}; }


[[nodiscard]] inline Tensor5 pha_mat_spt(Workspace& ws) noexcept { return {203, ws[203]}; }


[[nodiscard]] inline ArrayOfTensor7 pha_mat_sptDOITOpt(Workspace& ws) noexcept { return {205, ws[205]}; }


[[nodiscard]] inline Agenda pha_mat_spt_agenda(Workspace& ws) noexcept { return {204, ws[204]}; }


[[nodiscard]] inline Numeric planet_rotation_period(Workspace& ws) noexcept { return {206, ws[206]}; }


[[nodiscard]] inline ArrayOfAgenda pnd_agenda_array(Workspace& ws) noexcept { return {207, ws[207]}; }


[[nodiscard]] inline ArrayOfArrayOfString pnd_agenda_array_input_names(Workspace& ws) noexcept { return {210, ws[210]}; }


[[nodiscard]] inline Matrix pnd_agenda_input(Workspace& ws) noexcept { return {208, ws[208]}; }


[[nodiscard]] inline ArrayOfString pnd_agenda_input_names(Workspace& ws) noexcept { return {211, ws[211]}; }


[[nodiscard]] inline Vector pnd_agenda_input_t(Workspace& ws) noexcept { return {209, ws[209]}; }


[[nodiscard]] inline Matrix pnd_data(Workspace& ws) noexcept { return {212, ws[212]}; }


[[nodiscard]] inline Tensor4 pnd_field(Workspace& ws) noexcept { return {213, ws[213]}; }


[[nodiscard]] inline ArrayOfGriddedField3 pnd_field_raw(Workspace& ws) noexcept { return {215, ws[215]}; }


[[nodiscard]] inline Vector pnd_size_grid(Workspace& ws) noexcept { return {214, ws[214]}; }


[[nodiscard]] inline Ppath ppath(Workspace& ws) noexcept { return {216, ws[216]}; }


[[nodiscard]] inline Agenda ppath_agenda(Workspace& ws) noexcept { return {217, ws[217]}; }


[[nodiscard]] inline ArrayOfPpath ppath_field(Workspace& ws) noexcept { return {218, ws[218]}; }


[[nodiscard]] inline Index ppath_inside_cloudbox_do(Workspace& ws) noexcept { return {219, ws[219]}; }


[[nodiscard]] inline Numeric ppath_lmax(Workspace& ws) noexcept { return {220, ws[220]}; }


[[nodiscard]] inline Numeric ppath_lraytrace(Workspace& ws) noexcept { return {221, ws[221]}; }


[[nodiscard]] inline Ppath ppath_step(Workspace& ws) noexcept { return {222, ws[222]}; }


[[nodiscard]] inline Agenda ppath_step_agenda(Workspace& ws) noexcept { return {223, ws[223]}; }


[[nodiscard]] inline Matrix ppvar_f(Workspace& ws) noexcept { return {224, ws[224]}; }


[[nodiscard]] inline Tensor3 ppvar_iy(Workspace& ws) noexcept { return {225, ws[225]}; }


[[nodiscard]] inline Matrix ppvar_mag(Workspace& ws) noexcept { return {226, ws[226]}; }


[[nodiscard]] inline EnergyLevelMap ppvar_nlte(Workspace& ws) noexcept { return {227, ws[227]}; }


[[nodiscard]] inline Matrix ppvar_optical_depth(Workspace& ws) noexcept { return {230, ws[230]}; }


[[nodiscard]] inline Vector ppvar_p(Workspace& ws) noexcept { return {228, ws[228]}; }


[[nodiscard]] inline Matrix ppvar_pnd(Workspace& ws) noexcept { return {229, ws[229]}; }


[[nodiscard]] inline Vector ppvar_t(Workspace& ws) noexcept { return {231, ws[231]}; }


[[nodiscard]] inline Tensor4 ppvar_trans_cumulat(Workspace& ws) noexcept { return {232, ws[232]}; }


[[nodiscard]] inline Tensor4 ppvar_trans_partial(Workspace& ws) noexcept { return {233, ws[233]}; }


[[nodiscard]] inline Matrix ppvar_vmr(Workspace& ws) noexcept { return {234, ws[234]}; }


[[nodiscard]] inline Matrix ppvar_wind(Workspace& ws) noexcept { return {235, ws[235]}; }


[[nodiscard]] inline ArrayOfPropagationMatrix propmat_clearsky(Workspace& ws) noexcept { return {236, ws[236]}; }


[[nodiscard]] inline Agenda propmat_clearsky_agenda(Workspace& ws) noexcept { return {238, ws[238]}; }


[[nodiscard]] inline Index propmat_clearsky_agenda_checked(Workspace& ws) noexcept { return {237, ws[237]}; }


[[nodiscard]] inline Tensor7 propmat_clearsky_field(Workspace& ws) noexcept { return {239, ws[239]}; }


[[nodiscard]] inline Matrix psd_data(Workspace& ws) noexcept { return {240, ws[240]}; }


[[nodiscard]] inline Vector psd_size_grid(Workspace& ws) noexcept { return {241, ws[241]}; }


[[nodiscard]] inline Tensor5 radiance_field(Workspace& ws) noexcept { return {245, ws[245]}; }


[[nodiscard]] inline Vector range_bins(Workspace& ws) noexcept { return {246, ws[246]}; }


[[nodiscard]] inline Vector refellipsoid(Workspace& ws) noexcept { return {250, ws[250]}; }


[[nodiscard]] inline Numeric refr_index_air(Workspace& ws) noexcept { return {247, ws[247]}; }


[[nodiscard]] inline Agenda refr_index_air_agenda(Workspace& ws) noexcept { return {248, ws[248]}; }


[[nodiscard]] inline Numeric refr_index_air_group(Workspace& ws) noexcept { return {249, ws[249]}; }


[[nodiscard]] inline ArrayOfArrayOfMatrix relmat_per_band(Workspace& ws) noexcept { return {251, ws[251]}; }


[[nodiscard]] inline ArrayOfIndex relmat_type_per_band(Workspace& ws) noexcept { return {252, ws[252]}; }


[[nodiscard]] inline Index retrieval_checked(Workspace& ws) noexcept { return {253, ws[253]}; }


[[nodiscard]] inline Vector retrieval_eo(Workspace& ws) noexcept { return {254, ws[254]}; }


[[nodiscard]] inline Vector retrieval_ss(Workspace& ws) noexcept { return {255, ws[255]}; }


[[nodiscard]] inline Numeric rte_alonglos_v(Workspace& ws) noexcept { return {256, ws[256]}; }


[[nodiscard]] inline Vector rte_los(Workspace& ws) noexcept { return {257, ws[257]}; }


[[nodiscard]] inline Vector rte_pos(Workspace& ws) noexcept { return {258, ws[258]}; }


[[nodiscard]] inline Vector rte_pos2(Workspace& ws) noexcept { return {259, ws[259]}; }


[[nodiscard]] inline Vector rtp_los(Workspace& ws) noexcept { return {261, ws[261]}; }


[[nodiscard]] inline Vector rtp_mag(Workspace& ws) noexcept { return {260, ws[260]}; }


[[nodiscard]] inline EnergyLevelMap rtp_nlte(Workspace& ws) noexcept { return {265, ws[265]}; }


[[nodiscard]] inline Vector rtp_pos(Workspace& ws) noexcept { return {262, ws[262]}; }


[[nodiscard]] inline Numeric rtp_pressure(Workspace& ws) noexcept { return {263, ws[263]}; }


[[nodiscard]] inline Numeric rtp_temperature(Workspace& ws) noexcept { return {264, ws[264]}; }


[[nodiscard]] inline Vector rtp_vmr(Workspace& ws) noexcept { return {266, ws[266]}; }


[[nodiscard]] inline ArrayOfArrayOfSingleScatteringData scat_data(Workspace& ws) noexcept { return {267, ws[267]}; }


[[nodiscard]] inline Index scat_data_checked(Workspace& ws) noexcept { return {268, ws[268]}; }


[[nodiscard]] inline ArrayOfArrayOfSingleScatteringData scat_data_mono(Workspace& ws) noexcept { return {270, ws[270]}; }


[[nodiscard]] inline ArrayOfArrayOfSingleScatteringData scat_data_raw(Workspace& ws) noexcept { return {269, ws[269]}; }


[[nodiscard]] inline SingleScatteringData scat_data_single(Workspace& ws) noexcept { return {271, ws[271]}; }


[[nodiscard]] inline Index scat_lat_index(Workspace& ws) noexcept { return {272, ws[272]}; }


[[nodiscard]] inline Index scat_lon_index(Workspace& ws) noexcept { return {273, ws[273]}; }


[[nodiscard]] inline ArrayOfArrayOfScatteringMetaData scat_meta(Workspace& ws) noexcept { return {275, ws[275]}; }


[[nodiscard]] inline ScatteringMetaData scat_meta_single(Workspace& ws) noexcept { return {274, ws[274]}; }


[[nodiscard]] inline Index scat_p_index(Workspace& ws) noexcept { return {276, ws[276]}; }


[[nodiscard]] inline ArrayOfString scat_species(Workspace& ws) noexcept { return {277, ws[277]}; }


[[nodiscard]] inline Numeric scat_species_a(Workspace& ws) noexcept { return {278, ws[278]}; }


[[nodiscard]] inline Numeric scat_species_b(Workspace& ws) noexcept { return {279, ws[279]}; }


[[nodiscard]] inline Vector scat_species_x(Workspace& ws) noexcept { return {280, ws[280]}; }


[[nodiscard]] inline Index sensor_checked(Workspace& ws) noexcept { return {281, ws[281]}; }


[[nodiscard]] inline Matrix sensor_description_amsu(Workspace& ws) noexcept { return {282, ws[282]}; }


[[nodiscard]] inline Matrix sensor_los(Workspace& ws) noexcept { return {283, ws[283]}; }


[[nodiscard]] inline Index sensor_norm(Workspace& ws) noexcept { return {284, ws[284]}; }


[[nodiscard]] inline Matrix sensor_pol(Workspace& ws) noexcept { return {285, ws[285]}; }


[[nodiscard]] inline Matrix sensor_pos(Workspace& ws) noexcept { return {286, ws[286]}; }


[[nodiscard]] inline Sparse sensor_response(Workspace& ws) noexcept { return {287, ws[287]}; }


[[nodiscard]] inline Vector sensor_response_aa(Workspace& ws) noexcept { return {288, ws[288]}; }


[[nodiscard]] inline Agenda sensor_response_agenda(Workspace& ws) noexcept { return {289, ws[289]}; }


[[nodiscard]] inline Matrix sensor_response_dlos(Workspace& ws) noexcept { return {290, ws[290]}; }


[[nodiscard]] inline Matrix sensor_response_dlos_grid(Workspace& ws) noexcept { return {291, ws[291]}; }


[[nodiscard]] inline Vector sensor_response_f(Workspace& ws) noexcept { return {292, ws[292]}; }


[[nodiscard]] inline Vector sensor_response_f_grid(Workspace& ws) noexcept { return {293, ws[293]}; }


[[nodiscard]] inline ArrayOfIndex sensor_response_pol(Workspace& ws) noexcept { return {294, ws[294]}; }


[[nodiscard]] inline ArrayOfIndex sensor_response_pol_grid(Workspace& ws) noexcept { return {295, ws[295]}; }


[[nodiscard]] inline Vector sensor_time(Workspace& ws) noexcept { return {296, ws[296]}; }


[[nodiscard]] inline String sideband_mode(Workspace& ws) noexcept { return {297, ws[297]}; }


[[nodiscard]] inline ArrayOfString sideband_mode_multi(Workspace& ws) noexcept { return {298, ws[298]}; }


[[nodiscard]] inline GriddedField1 sideband_response(Workspace& ws) noexcept { return {299, ws[299]}; }


[[nodiscard]] inline ArrayOfGriddedField1 sideband_response_multi(Workspace& ws) noexcept { return {300, ws[300]}; }


[[nodiscard]] inline Tensor3 specific_heat_capacity(Workspace& ws) noexcept { return {303, ws[303]}; }


[[nodiscard]] inline Tensor5 spectral_irradiance_field(Workspace& ws) noexcept { return {301, ws[301]}; }


[[nodiscard]] inline Tensor7 spectral_radiance_field(Workspace& ws) noexcept { return {302, ws[302]}; }


[[nodiscard]] inline Vector specular_los(Workspace& ws) noexcept { return {304, ws[304]}; }


[[nodiscard]] inline Agenda spt_calc_agenda(Workspace& ws) noexcept { return {305, ws[305]}; }


[[nodiscard]] inline Matrix src_coef(Workspace& ws) noexcept { return {308, ws[308]}; }


[[nodiscard]] inline ArrayOfMatrix src_coef_per_species(Workspace& ws) noexcept { return {309, ws[309]}; }


[[nodiscard]] inline ArrayOfMatrix src_xsec_per_species(Workspace& ws) noexcept { return {307, ws[307]}; }


[[nodiscard]] inline Index stokes_dim(Workspace& ws) noexcept { return {306, ws[306]}; }


[[nodiscard]] inline Vector stokes_rotation(Workspace& ws) noexcept { return {310, ws[310]}; }


[[nodiscard]] inline GriddedField3 surface_complex_refr_index(Workspace& ws) noexcept { return {311, ws[311]}; }


[[nodiscard]] inline Matrix surface_emission(Workspace& ws) noexcept { return {312, ws[312]}; }


[[nodiscard]] inline Matrix surface_los(Workspace& ws) noexcept { return {313, ws[313]}; }


[[nodiscard]] inline Vector surface_normal(Workspace& ws) noexcept { return {314, ws[314]}; }


[[nodiscard]] inline Tensor3 surface_props_data(Workspace& ws) noexcept { return {315, ws[315]}; }


[[nodiscard]] inline ArrayOfString surface_props_names(Workspace& ws) noexcept { return {316, ws[316]}; }


[[nodiscard]] inline Tensor3 surface_reflectivity(Workspace& ws) noexcept { return {322, ws[322]}; }


[[nodiscard]] inline Tensor4 surface_rmatrix(Workspace& ws) noexcept { return {317, ws[317]}; }


[[nodiscard]] inline Agenda surface_rtprop_agenda(Workspace& ws) noexcept { return {318, ws[318]}; }


[[nodiscard]] inline ArrayOfAgenda surface_rtprop_agenda_array(Workspace& ws) noexcept { return {319, ws[319]}; }


[[nodiscard]] inline Agenda surface_rtprop_sub_agenda(Workspace& ws) noexcept { return {320, ws[320]}; }


[[nodiscard]] inline Matrix surface_rv_rh(Workspace& ws) noexcept { return {323, ws[323]}; }


[[nodiscard]] inline Vector surface_scalar_reflectivity(Workspace& ws) noexcept { return {324, ws[324]}; }


[[nodiscard]] inline Numeric surface_skin_t(Workspace& ws) noexcept { return {321, ws[321]}; }


[[nodiscard]] inline Index surface_type(Workspace& ws) noexcept { return {325, ws[325]}; }


[[nodiscard]] inline Numeric surface_type_aux(Workspace& ws) noexcept { return {326, ws[326]}; }


[[nodiscard]] inline GriddedField2 surface_type_mask(Workspace& ws) noexcept { return {327, ws[327]}; }


[[nodiscard]] inline Tensor3 t_field(Workspace& ws) noexcept { return {338, ws[338]}; }


[[nodiscard]] inline GriddedField3 t_field_raw(Workspace& ws) noexcept { return {340, ws[340]}; }


[[nodiscard]] inline Matrix t_surface(Workspace& ws) noexcept { return {342, ws[342]}; }


[[nodiscard]] inline ArrayOfTelsemAtlas telsem_atlases(Workspace& ws) noexcept { return {328, ws[328]}; }


[[nodiscard]] inline TessemNN tessem_neth(Workspace& ws) noexcept { return {329, ws[329]}; }


[[nodiscard]] inline TessemNN tessem_netv(Workspace& ws) noexcept { return {330, ws[330]}; }


[[nodiscard]] inline Agenda test_agenda(Workspace& ws) noexcept { return {331, ws[331]}; }


[[nodiscard]] inline ArrayOfAgenda test_agenda_array(Workspace& ws) noexcept { return {332, ws[332]}; }


[[nodiscard]] inline Time time(Workspace& ws) noexcept { return {333, ws[333]}; }


[[nodiscard]] inline ArrayOfTime time_grid(Workspace& ws) noexcept { return {335, ws[335]}; }


[[nodiscard]] inline ArrayOfTime time_stamps(Workspace& ws) noexcept { return {336, ws[336]}; }


[[nodiscard]] inline Timer timer(Workspace& ws) noexcept { return {334, ws[334]}; }


[[nodiscard]] inline Matrix transmitter_pos(Workspace& ws) noexcept { return {337, ws[337]}; }


[[nodiscard]] inline Verbosity verbosity(Workspace& ws) noexcept { return {343, ws[343]}; }


[[nodiscard]] inline Tensor4 vmr_field(Workspace& ws) noexcept { return {344, ws[344]}; }


[[nodiscard]] inline ArrayOfGriddedField3 vmr_field_raw(Workspace& ws) noexcept { return {345, ws[345]}; }


[[nodiscard]] inline Agenda water_p_eq_agenda(Workspace& ws) noexcept { return {346, ws[346]}; }


[[nodiscard]] inline Tensor3 water_p_eq_field(Workspace& ws) noexcept { return {347, ws[347]}; }


[[nodiscard]] inline Index wigner_initialized(Workspace& ws) noexcept { return {348, ws[348]}; }


[[nodiscard]] inline Tensor3 wind_u_field(Workspace& ws) noexcept { return {349, ws[349]}; }


[[nodiscard]] inline GriddedField3 wind_u_field_raw(Workspace& ws) noexcept { return {350, ws[350]}; }


[[nodiscard]] inline Tensor3 wind_v_field(Workspace& ws) noexcept { return {351, ws[351]}; }


[[nodiscard]] inline GriddedField3 wind_v_field_raw(Workspace& ws) noexcept { return {352, ws[352]}; }


[[nodiscard]] inline Tensor3 wind_w_field(Workspace& ws) noexcept { return {353, ws[353]}; }


[[nodiscard]] inline GriddedField3 wind_w_field_raw(Workspace& ws) noexcept { return {354, ws[354]}; }


[[nodiscard]] inline ArrayOfIndex wmrf_channels(Workspace& ws) noexcept { return {355, ws[355]}; }


[[nodiscard]] inline Sparse wmrf_weights(Workspace& ws) noexcept { return {356, ws[356]}; }


[[nodiscard]] inline Vector x(Workspace& ws) noexcept { return {358, ws[358]}; }


[[nodiscard]] inline Vector xa(Workspace& ws) noexcept { return {359, ws[359]}; }


[[nodiscard]] inline Index xml_output_type(Workspace& ws) noexcept { return {357, ws[357]}; }


[[nodiscard]] inline Vector y(Workspace& ws) noexcept { return {360, ws[360]}; }


[[nodiscard]] inline ArrayOfVector y_aux(Workspace& ws) noexcept { return {361, ws[361]}; }


[[nodiscard]] inline Vector y_baseline(Workspace& ws) noexcept { return {362, ws[362]}; }


[[nodiscard]] inline Vector y_f(Workspace& ws) noexcept { return {363, ws[363]}; }


[[nodiscard]] inline Matrix y_geo(Workspace& ws) noexcept { return {364, ws[364]}; }


[[nodiscard]] inline Matrix y_los(Workspace& ws) noexcept { return {365, ws[365]}; }


[[nodiscard]] inline ArrayOfIndex y_pol(Workspace& ws) noexcept { return {366, ws[366]}; }


[[nodiscard]] inline Matrix y_pos(Workspace& ws) noexcept { return {367, ws[367]}; }


[[nodiscard]] inline Vector yb(Workspace& ws) noexcept { return {368, ws[368]}; }


[[nodiscard]] inline ArrayOfVector ybatch(Workspace& ws) noexcept { return {369, ws[369]}; }


[[nodiscard]] inline ArrayOfArrayOfVector ybatch_aux(Workspace& ws) noexcept { return {370, ws[370]}; }


[[nodiscard]] inline Agenda ybatch_calc_agenda(Workspace& ws) noexcept { return {371, ws[371]}; }


[[nodiscard]] inline ArrayOfVector ybatch_corr(Workspace& ws) noexcept { return {373, ws[373]}; }


[[nodiscard]] inline Index ybatch_index(Workspace& ws) noexcept { return {372, ws[372]}; }


[[nodiscard]] inline ArrayOfMatrix ybatch_jacobians(Workspace& ws) noexcept { return {374, ws[374]}; }


[[nodiscard]] inline Index ybatch_n(Workspace& ws) noexcept { return {375, ws[375]}; }


[[nodiscard]] inline Index ybatch_start(Workspace& ws) noexcept { return {376, ws[376]}; }


[[nodiscard]] inline Vector yf(Workspace& ws) noexcept { return {377, ws[377]}; }


[[nodiscard]] inline Tensor3 z_field(Workspace& ws) noexcept { return {381, ws[381]}; }


[[nodiscard]] inline GriddedField3 z_field_raw(Workspace& ws) noexcept { return {382, ws[382]}; }


[[nodiscard]] inline Numeric z_hse_accuracy(Workspace& ws) noexcept { return {383, ws[383]}; }


[[nodiscard]] inline Matrix z_surface(Workspace& ws) noexcept { return {384, ws[384]}; }


[[nodiscard]] inline Vector za_grid(Workspace& ws) noexcept { return {378, ws[378]}; }


[[nodiscard]] inline Vector za_grid_weights(Workspace& ws) noexcept { return {379, ws[379]}; }


[[nodiscard]] inline Index za_index(Workspace& ws) noexcept { return {380, ws[380]}; }


[[nodiscard]] inline

AbsorptionLines AbsorptionLinesCreate(

            Workspace& ws,

            const Group::AbsorptionLines& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 0}));

  AbsorptionLines val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Agenda AgendaCreate(

            Workspace& ws,

            const Group::Agenda& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 1}));

  Agenda val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfAbsorptionLines ArrayOfAbsorptionLinesCreate(

            Workspace& ws,

            const Group::ArrayOfAbsorptionLines& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 3}));

  ArrayOfAbsorptionLines val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfAgenda ArrayOfAgendaCreate(

            Workspace& ws,

            const Group::ArrayOfAgenda& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 5}));

  ArrayOfAgenda val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfAbsorptionLines ArrayOfArrayOfAbsorptionLinesCreate(

            Workspace& ws,

            const Group::ArrayOfArrayOfAbsorptionLines& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 4}));

  ArrayOfArrayOfAbsorptionLines val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfGriddedField1 ArrayOfArrayOfGriddedField1Create(

            Workspace& ws,

            const Group::ArrayOfArrayOfGriddedField1& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 6}));

  ArrayOfArrayOfGriddedField1 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfGriddedField2 ArrayOfArrayOfGriddedField2Create(

            Workspace& ws,

            const Group::ArrayOfArrayOfGriddedField2& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 7}));

  ArrayOfArrayOfGriddedField2 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfGriddedField3 ArrayOfArrayOfGriddedField3Create(

            Workspace& ws,

            const Group::ArrayOfArrayOfGriddedField3& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 8}));

  ArrayOfArrayOfGriddedField3 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfIndex ArrayOfArrayOfIndexCreate(

            Workspace& ws,

            const Group::ArrayOfArrayOfIndex& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 9}));

  ArrayOfArrayOfIndex val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfMatrix ArrayOfArrayOfMatrixCreate(

            Workspace& ws,

            const Group::ArrayOfArrayOfMatrix& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 10}));

  ArrayOfArrayOfMatrix val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfPropagationMatrix ArrayOfArrayOfPropagationMatrixCreate(

            Workspace& ws,

            const Group::ArrayOfArrayOfPropagationMatrix& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 12}));

  ArrayOfArrayOfPropagationMatrix val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfRadiationVector ArrayOfArrayOfRadiationVectorCreate(

            Workspace& ws,

            const Group::ArrayOfArrayOfRadiationVector& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 13}));

  ArrayOfArrayOfRadiationVector val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfScatteringMetaData ArrayOfArrayOfScatteringMetaDataCreate(

            Workspace& ws,

            const Group::ArrayOfArrayOfScatteringMetaData& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 14}));

  ArrayOfArrayOfScatteringMetaData val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfSingleScatteringData ArrayOfArrayOfSingleScatteringDataCreate(

            Workspace& ws,

            const Group::ArrayOfArrayOfSingleScatteringData& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 15}));

  ArrayOfArrayOfSingleScatteringData val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfSpeciesTag ArrayOfArrayOfSpeciesTagCreate(

            Workspace& ws,

            const Group::ArrayOfArrayOfSpeciesTag& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 16}));

  ArrayOfArrayOfSpeciesTag val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfStokesVector ArrayOfArrayOfStokesVectorCreate(

            Workspace& ws,

            const Group::ArrayOfArrayOfStokesVector& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 17}));

  ArrayOfArrayOfStokesVector val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfString ArrayOfArrayOfStringCreate(

            Workspace& ws,

            const Group::ArrayOfArrayOfString& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 18}));

  ArrayOfArrayOfString val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfTensor3 ArrayOfArrayOfTensor3Create(

            Workspace& ws,

            const Group::ArrayOfArrayOfTensor3& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 19}));

  ArrayOfArrayOfTensor3 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfTensor6 ArrayOfArrayOfTensor6Create(

            Workspace& ws,

            const Group::ArrayOfArrayOfTensor6& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 20}));

  ArrayOfArrayOfTensor6 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfTime ArrayOfArrayOfTimeCreate(

            Workspace& ws,

            const Group::ArrayOfArrayOfTime& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 21}));

  ArrayOfArrayOfTime val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfTransmissionMatrix ArrayOfArrayOfTransmissionMatrixCreate(

            Workspace& ws,

            const Group::ArrayOfArrayOfTransmissionMatrix& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 22}));

  ArrayOfArrayOfTransmissionMatrix val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfArrayOfVector ArrayOfArrayOfVectorCreate(

            Workspace& ws,

            const Group::ArrayOfArrayOfVector& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 23}));

  ArrayOfArrayOfVector val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfCIARecord ArrayOfCIARecordCreate(

            Workspace& ws,

            const Group::ArrayOfCIARecord& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 24}));

  ArrayOfCIARecord val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfGriddedField1 ArrayOfGriddedField1Create(

            Workspace& ws,

            const Group::ArrayOfGriddedField1& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 25}));

  ArrayOfGriddedField1 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfGriddedField2 ArrayOfGriddedField2Create(

            Workspace& ws,

            const Group::ArrayOfGriddedField2& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 26}));

  ArrayOfGriddedField2 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfGriddedField3 ArrayOfGriddedField3Create(

            Workspace& ws,

            const Group::ArrayOfGriddedField3& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 27}));

  ArrayOfGriddedField3 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfGriddedField4 ArrayOfGriddedField4Create(

            Workspace& ws,

            const Group::ArrayOfGriddedField4& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 28}));

  ArrayOfGriddedField4 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfIndex ArrayOfIndexCreate(

            Workspace& ws,

            const Group::ArrayOfIndex& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 29}));

  ArrayOfIndex val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfMatrix ArrayOfMatrixCreate(

            Workspace& ws,

            const Group::ArrayOfMatrix& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 30}));

  ArrayOfMatrix val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfPpath ArrayOfPpathCreate(

            Workspace& ws,

            const Group::ArrayOfPpath& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 11}));

  ArrayOfPpath val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfPropagationMatrix ArrayOfPropagationMatrixCreate(

            Workspace& ws,

            const Group::ArrayOfPropagationMatrix& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 31}));

  ArrayOfPropagationMatrix val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfQuantumIdentifier ArrayOfQuantumIdentifierCreate(

            Workspace& ws,

            const Group::ArrayOfQuantumIdentifier& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 32}));

  ArrayOfQuantumIdentifier val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfRadiationVector ArrayOfRadiationVectorCreate(

            Workspace& ws,

            const Group::ArrayOfRadiationVector& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 33}));

  ArrayOfRadiationVector val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfRetrievalQuantity ArrayOfRetrievalQuantityCreate(

            Workspace& ws,

            const Group::ArrayOfRetrievalQuantity& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 34}));

  ArrayOfRetrievalQuantity val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfScatteringMetaData ArrayOfScatteringMetaDataCreate(

            Workspace& ws,

            const Group::ArrayOfScatteringMetaData& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 35}));

  ArrayOfScatteringMetaData val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfSingleScatteringData ArrayOfSingleScatteringDataCreate(

            Workspace& ws,

            const Group::ArrayOfSingleScatteringData& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 36}));

  ArrayOfSingleScatteringData val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfSparse ArrayOfSparseCreate(

            Workspace& ws,

            const Group::ArrayOfSparse& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 37}));

  ArrayOfSparse val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfStokesVector ArrayOfStokesVectorCreate(

            Workspace& ws,

            const Group::ArrayOfStokesVector& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 38}));

  ArrayOfStokesVector val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfString ArrayOfStringCreate(

            Workspace& ws,

            const Group::ArrayOfString& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 39}));

  ArrayOfString val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfTelsemAtlas ArrayOfTelsemAtlasCreate(

            Workspace& ws,

            const Group::ArrayOfTelsemAtlas& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 40}));

  ArrayOfTelsemAtlas val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfTensor3 ArrayOfTensor3Create(

            Workspace& ws,

            const Group::ArrayOfTensor3& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 41}));

  ArrayOfTensor3 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfTensor4 ArrayOfTensor4Create(

            Workspace& ws,

            const Group::ArrayOfTensor4& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 42}));

  ArrayOfTensor4 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfTensor5 ArrayOfTensor5Create(

            Workspace& ws,

            const Group::ArrayOfTensor5& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 43}));

  ArrayOfTensor5 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfTensor6 ArrayOfTensor6Create(

            Workspace& ws,

            const Group::ArrayOfTensor6& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 44}));

  ArrayOfTensor6 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfTensor7 ArrayOfTensor7Create(

            Workspace& ws,

            const Group::ArrayOfTensor7& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 45}));

  ArrayOfTensor7 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfTime ArrayOfTimeCreate(

            Workspace& ws,

            const Group::ArrayOfTime& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 46}));

  ArrayOfTime val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfTransmissionMatrix ArrayOfTransmissionMatrixCreate(

            Workspace& ws,

            const Group::ArrayOfTransmissionMatrix& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 47}));

  ArrayOfTransmissionMatrix val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfVector ArrayOfVectorCreate(

            Workspace& ws,

            const Group::ArrayOfVector& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 48}));

  ArrayOfVector val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ArrayOfXsecRecord ArrayOfXsecRecordCreate(

            Workspace& ws,

            const Group::ArrayOfXsecRecord& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 49}));

  ArrayOfXsecRecord val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

CIARecord CIARecordCreate(

            Workspace& ws,

            const Group::CIARecord& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 50}));

  CIARecord val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

CovarianceMatrix CovarianceMatrixCreate(

            Workspace& ws,

            const Group::CovarianceMatrix& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 51}));

  CovarianceMatrix val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

EnergyLevelMap EnergyLevelMapCreate(

            Workspace& ws,

            const Group::EnergyLevelMap& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 52}));

  EnergyLevelMap val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

GasAbsLookup GasAbsLookupCreate(

            Workspace& ws,

            const Group::GasAbsLookup& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 53}));

  GasAbsLookup val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

GridPos GridPosCreate(

            Workspace& ws,

            const Group::GridPos& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 54}));

  GridPos val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

GriddedField1 GriddedField1Create(

            Workspace& ws,

            const Group::GriddedField1& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 55}));

  GriddedField1 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

GriddedField2 GriddedField2Create(

            Workspace& ws,

            const Group::GriddedField2& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 56}));

  GriddedField2 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

GriddedField3 GriddedField3Create(

            Workspace& ws,

            const Group::GriddedField3& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 57}));

  GriddedField3 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

GriddedField4 GriddedField4Create(

            Workspace& ws,

            const Group::GriddedField4& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 58}));

  GriddedField4 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

GriddedField5 GriddedField5Create(

            Workspace& ws,

            const Group::GriddedField5& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 59}));

  GriddedField5 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

GriddedField6 GriddedField6Create(

            Workspace& ws,

            const Group::GriddedField6& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 60}));

  GriddedField6 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

HitranRelaxationMatrixData HitranRelaxationMatrixDataCreate(

            Workspace& ws,

            const Group::HitranRelaxationMatrixData& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 61}));

  HitranRelaxationMatrixData val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Index IndexCreate(

            Workspace& ws,

            const Group::Index& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 62}));

  Index val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

MCAntenna MCAntennaCreate(

            Workspace& ws,

            const Group::MCAntenna& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 63}));

  MCAntenna val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Matrix MatrixCreate(

            Workspace& ws,

            const Group::Matrix& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 64}));

  Matrix val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Numeric NumericCreate(

            Workspace& ws,

            const Group::Numeric& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 65}));

  Numeric val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Ppath PpathCreate(

            Workspace& ws,

            const Group::Ppath& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 66}));

  Ppath val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

PropagationMatrix PropagationMatrixCreate(

            Workspace& ws,

            const Group::PropagationMatrix& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 67}));

  PropagationMatrix val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

QuantumIdentifier QuantumIdentifierCreate(

            Workspace& ws,

            const Group::QuantumIdentifier& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 68}));

  QuantumIdentifier val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

RadiationVector RadiationVectorCreate(

            Workspace& ws,

            const Group::RadiationVector& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 69}));

  RadiationVector val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Rational RationalCreate(

            Workspace& ws,

            const Group::Rational& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 70}));

  Rational val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

ScatteringMetaData ScatteringMetaDataCreate(

            Workspace& ws,

            const Group::ScatteringMetaData& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 71}));

  ScatteringMetaData val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

SingleScatteringData SingleScatteringDataCreate(

            Workspace& ws,

            const Group::SingleScatteringData& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 72}));

  SingleScatteringData val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Sparse SparseCreate(

            Workspace& ws,

            const Group::Sparse& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 73}));

  Sparse val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

SpeciesAuxData SpeciesAuxDataCreate(

            Workspace& ws,

            const Group::SpeciesAuxData& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 74}));

  SpeciesAuxData val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

StokesVector StokesVectorCreate(

            Workspace& ws,

            const Group::StokesVector& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 75}));

  StokesVector val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

String StringCreate(

            Workspace& ws,

            const Group::String& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 76}));

  String val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

TelsemAtlas TelsemAtlasCreate(

            Workspace& ws,

            const Group::TelsemAtlas& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 77}));

  TelsemAtlas val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Tensor3 Tensor3Create(

            Workspace& ws,

            const Group::Tensor3& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 78}));

  Tensor3 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Tensor4 Tensor4Create(

            Workspace& ws,

            const Group::Tensor4& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 79}));

  Tensor4 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Tensor5 Tensor5Create(

            Workspace& ws,

            const Group::Tensor5& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 80}));

  Tensor5 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Tensor6 Tensor6Create(

            Workspace& ws,

            const Group::Tensor6& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 81}));

  Tensor6 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Tensor7 Tensor7Create(

            Workspace& ws,

            const Group::Tensor7& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 82}));

  Tensor7 val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

TessemNN TessemNNCreate(

            Workspace& ws,

            const Group::TessemNN& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 85}));

  TessemNN val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Time TimeCreate(

            Workspace& ws,

            const Group::Time& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 84}));

  Time val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Timer TimerCreate(

            Workspace& ws,

            const Group::Timer& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 83}));

  Timer val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

TransmissionMatrix TransmissionMatrixCreate(

            Workspace& ws,

            const Group::TransmissionMatrix& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 86}));

  TransmissionMatrix val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Vector VectorCreate(

            Workspace& ws,

            const Group::Vector& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 87}));

  Vector val{ind, ws[ind]};

  return val = inval;

}


[[nodiscard]] inline

Verbosity VerbosityCreate(

            Workspace& ws,

            const Group::Verbosity& inval,

            const Group::String& name,

            const Group::String& desc="nodescription") {

  const std::size_t ind = std::size_t(ws.add_wsv_inplace({name.c_str(), desc.c_str(), 88}));

  Verbosity val{ind, ws[ind]};

  return val = inval;

}


}  // ARTS::Var


namespace ARTS::Method {

inline void AbsInputFromAtmFields(

            Workspace& ws) {

  AbsInputFromAtmFields(Var::abs_p(ws).value(), Var::abs_t(ws).value(), Var::abs_vmrs(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::t_field(ws).value(), Var::vmr_field(ws).value(), Var::verbosity(ws).value());

}


inline void AbsInputFromRteScalars(

            Workspace& ws) {

  AbsInputFromRteScalars(Var::abs_p(ws).value(), Var::abs_t(ws).value(), Var::abs_vmrs(ws).value(), Var::rtp_pressure(ws).value(), Var::rtp_temperature(ws).value(), Var::rtp_vmr(ws).value(), Var::verbosity(ws).value());

}


inline void abs_cia_dataAddCIARecord(

            Workspace& ws,

      const Var::CIARecord cia_record,

      const Var::Index clobber=Group::Index{0}) {

  abs_cia_dataAddCIARecord(Var::abs_cia_data(ws).value(), cia_record.value(), clobber.value(), Var::verbosity(ws).value());

}


inline void abs_cia_dataReadFromCIA(

            Workspace& ws,

      const Var::String catalogpath) {

  abs_cia_dataReadFromCIA(Var::abs_cia_data(ws).value(), Var::abs_species(ws).value(), catalogpath.value(), Var::verbosity(ws).value());

}


inline void abs_cia_dataReadFromXML(

            Workspace& ws,

      const Var::String filename=Group::String{""}) {

  abs_cia_dataReadFromXML(Var::abs_cia_data(ws).value(), Var::abs_species(ws).value(), filename.value(), Var::verbosity(ws).value());

}


inline void abs_coefCalcFromXsec(

            Workspace& ws) {

  abs_coefCalcFromXsec(Var::abs_coef(ws).value(), Var::src_coef(ws).value(), Var::dabs_coef_dx(ws).value(), Var::dsrc_coef_dx(ws).value(), Var::abs_coef_per_species(ws).value(), Var::src_coef_per_species(ws).value(), Var::abs_xsec_per_species(ws).value(), Var::src_xsec_per_species(ws).value(), Var::dabs_xsec_per_species_dx(ws).value(), Var::dsrc_xsec_per_species_dx(ws).value(), Var::abs_species(ws).value(), Var::jacobian_quantities(ws).value(), Var::abs_vmrs(ws).value(), Var::abs_p(ws).value(), Var::abs_t(ws).value(), Var::verbosity(ws).value());

}


inline void abs_cont_descriptionAppend(

            Workspace& ws,

      const Var::String tagname,

      const Var::String model,

      const Var::Vector userparam=Group::Vector{}) {

  abs_cont_descriptionAppend(Var::abs_cont_names(ws).value(), Var::abs_cont_models(ws).value(), Var::abs_cont_parameters(ws).value(), tagname.value(), model.value(), userparam.value(), Var::verbosity(ws).value());

}


inline void abs_cont_descriptionInit(

            Workspace& ws) {

  abs_cont_descriptionInit(Var::abs_cont_names(ws).value(), Var::abs_cont_models(ws).value(), Var::abs_cont_parameters(ws).value(), Var::verbosity(ws).value());

}


inline void abs_hitran_relmat_dataReadHitranRelmatDataAndLines(

            Workspace& ws,

      const Var::String basedir,

      const Var::Numeric linemixinglimit=Group::Numeric{-1},

      const Var::Numeric fmin=Group::Numeric{0},

      const Var::Numeric fmax=Group::Numeric{1e99},

      const Var::Numeric stot=Group::Numeric{0},

      const Var::String mode=Group::String{"VP_W"}) {

  abs_hitran_relmat_dataReadHitranRelmatDataAndLines(Var::abs_hitran_relmat_data(ws).value(), Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), basedir.value(), linemixinglimit.value(), fmin.value(), fmax.value(), stot.value(), mode.value(), Var::verbosity(ws).value());

}


inline void abs_linesCleanupEmpty(

            Workspace& ws) {

  abs_linesCleanupEmpty(Var::abs_lines(ws).value(), Var::verbosity(ws).value());

}


inline void abs_linesKeepBands(

            Workspace& ws,

      const Var::QuantumIdentifier qid,

      const Var::Index ignore_spec=Group::Index{1},

      const Var::Index ignore_isot=Group::Index{1}) {

  abs_linesKeepBands(Var::abs_lines(ws).value(), qid.value(), ignore_spec.value(), ignore_isot.value(), Var::verbosity(ws).value());

}


inline void abs_linesRemoveBand(

            Workspace& ws,

      const Var::QuantumIdentifier qid) {

  abs_linesRemoveBand(Var::abs_lines(ws).value(), qid.value(), Var::verbosity(ws).value());

}


inline void abs_linesRemoveUnusedLocalQuantumNumbers(

            Workspace& ws) {

  abs_linesRemoveUnusedLocalQuantumNumbers(Var::abs_lines(ws).value(), Var::verbosity(ws).value());

}


inline void abs_linesReplaceWithLines(

            Workspace& ws,

      const Var::ArrayOfAbsorptionLines replacing_lines) {

  abs_linesReplaceWithLines(Var::abs_lines(ws).value(), replacing_lines.value(), Var::verbosity(ws).value());

}


inline void abs_linesAppendWithLines(

            Workspace& ws,

      const Var::ArrayOfAbsorptionLines appending_lines,

      const Var::Index safe=Group::Index{1}) {

  abs_linesAppendWithLines(Var::abs_lines(ws).value(), appending_lines.value(), safe.value(), Var::verbosity(ws).value());

}


inline void abs_linesDeleteWithLines(

            Workspace& ws,

      const Var::ArrayOfAbsorptionLines deleting_lines) {

  abs_linesDeleteWithLines(Var::abs_lines(ws).value(), deleting_lines.value(), Var::verbosity(ws).value());

}


inline void abs_linesDeleteBadF0(

            Workspace& ws,

      const Var::Numeric f0,

      const Var::Index lower=Group::Index{1}) {

  abs_linesDeleteBadF0(Var::abs_lines(ws).value(), f0.value(), lower.value(), Var::verbosity(ws).value());

}


inline void abs_linesDeleteLinesWithUndefinedLocalQuanta(

            Workspace& ws) {

  abs_linesDeleteLinesWithUndefinedLocalQuanta(Var::abs_lines(ws).value(), Var::verbosity(ws).value());

}


inline void abs_linesDeleteLinesWithBadOrHighChangingJs(

            Workspace& ws) {

  abs_linesDeleteLinesWithBadOrHighChangingJs(Var::abs_lines(ws).value(), Var::verbosity(ws).value());

}


inline void abs_linesDeleteLinesWithQuantumNumberAbove(

            Workspace& ws,

      const Var::String quantumnumber,

      const Var::Index quantumnumber_value) {

  abs_linesDeleteLinesWithQuantumNumberAbove(Var::abs_lines(ws).value(), quantumnumber.value(), quantumnumber_value.value(), Var::verbosity(ws).value());

}


inline void abs_linesPrintDefinedQuantumNumbers(

            Workspace& ws) {

  abs_linesPrintDefinedQuantumNumbers(Var::abs_lines(ws).value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesReadSplitCatalog(

            Workspace& ws,

      const Var::String basename) {

  abs_lines_per_speciesReadSplitCatalog(Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), basename.value(), Var::verbosity(ws).value());

}


inline void abs_linesReadSpeciesSplitCatalog(

            Workspace& ws,

      const Var::String basename,

      const Var::Index robust=Group::Index{0}) {

  abs_linesReadSpeciesSplitCatalog(Var::abs_lines(ws).value(), basename.value(), robust.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesReadSpeciesSplitCatalog(

            Workspace& ws,

      const Var::String basename,

      const Var::Index robust=Group::Index{0}) {

  abs_lines_per_speciesReadSpeciesSplitCatalog(Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), basename.value(), robust.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetEmpty(

            Workspace& ws) {

  abs_lines_per_speciesSetEmpty(Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), Var::verbosity(ws).value());

}


inline void abs_linesSetEmptyBroadeningParametersToEmpty(

            Workspace& ws) {

  abs_linesSetEmptyBroadeningParametersToEmpty(Var::abs_lines(ws).value(), Var::verbosity(ws).value());

}


inline void abs_linesSetNormalization(

            Workspace& ws,

      const Var::String option) {

  abs_linesSetNormalization(Var::abs_lines(ws).value(), option.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetNormalization(

            Workspace& ws,

      const Var::String option) {

  abs_lines_per_speciesSetNormalization(Var::abs_lines_per_species(ws).value(), option.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetNormalizationForMatch(

            Workspace& ws,

      const Var::String option,

      const Var::QuantumIdentifier ID) {

  abs_linesSetNormalizationForMatch(Var::abs_lines(ws).value(), option.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetNormalizationForMatch(

            Workspace& ws,

      const Var::String option,

      const Var::QuantumIdentifier ID) {

  abs_lines_per_speciesSetNormalizationForMatch(Var::abs_lines_per_species(ws).value(), option.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetNormalizationForSpecies(

            Workspace& ws,

      const Var::String option,

      const Var::String species_tag) {

  abs_lines_per_speciesSetNormalizationForSpecies(Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), option.value(), species_tag.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetMirroring(

            Workspace& ws,

      const Var::String option) {

  abs_linesSetMirroring(Var::abs_lines(ws).value(), option.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetMirroring(

            Workspace& ws,

      const Var::String option) {

  abs_lines_per_speciesSetMirroring(Var::abs_lines_per_species(ws).value(), option.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetMirroringForMatch(

            Workspace& ws,

      const Var::String option,

      const Var::QuantumIdentifier ID) {

  abs_linesSetMirroringForMatch(Var::abs_lines(ws).value(), option.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetMirroringForMatch(

            Workspace& ws,

      const Var::String option,

      const Var::QuantumIdentifier ID) {

  abs_lines_per_speciesSetMirroringForMatch(Var::abs_lines_per_species(ws).value(), option.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetMirroringForSpecies(

            Workspace& ws,

      const Var::String option,

      const Var::String species_tag) {

  abs_lines_per_speciesSetMirroringForSpecies(Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), option.value(), species_tag.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetPopulation(

            Workspace& ws,

      const Var::String option) {

  abs_linesSetPopulation(Var::abs_lines(ws).value(), option.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetPopulation(

            Workspace& ws,

      const Var::String option) {

  abs_lines_per_speciesSetPopulation(Var::abs_lines_per_species(ws).value(), option.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetPopulationForMatch(

            Workspace& ws,

      const Var::String option,

      const Var::QuantumIdentifier ID) {

  abs_linesSetPopulationForMatch(Var::abs_lines(ws).value(), option.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetPopulationForMatch(

            Workspace& ws,

      const Var::String option,

      const Var::QuantumIdentifier ID) {

  abs_lines_per_speciesSetPopulationForMatch(Var::abs_lines_per_species(ws).value(), option.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetPopulationForSpecies(

            Workspace& ws,

      const Var::String option,

      const Var::String species_tag) {

  abs_lines_per_speciesSetPopulationForSpecies(Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), option.value(), species_tag.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetLineShapeType(

            Workspace& ws,

      const Var::String option) {

  abs_linesSetLineShapeType(Var::abs_lines(ws).value(), option.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetLineShapeType(

            Workspace& ws,

      const Var::String option) {

  abs_lines_per_speciesSetLineShapeType(Var::abs_lines_per_species(ws).value(), option.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetLineShapeTypeForMatch(

            Workspace& ws,

      const Var::String option,

      const Var::QuantumIdentifier ID) {

  abs_linesSetLineShapeTypeForMatch(Var::abs_lines(ws).value(), option.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetLineShapeTypeForMatch(

            Workspace& ws,

      const Var::String option,

      const Var::QuantumIdentifier ID) {

  abs_lines_per_speciesSetLineShapeTypeForMatch(Var::abs_lines_per_species(ws).value(), option.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetLineShapeTypeForSpecies(

            Workspace& ws,

      const Var::String option,

      const Var::String species_tag) {

  abs_lines_per_speciesSetLineShapeTypeForSpecies(Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), option.value(), species_tag.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetCutoff(

            Workspace& ws,

      const Var::String option,

      const Var::Numeric value) {

  abs_linesSetCutoff(Var::abs_lines(ws).value(), option.value(), value.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetCutoff(

            Workspace& ws,

      const Var::String option,

      const Var::Numeric value) {

  abs_lines_per_speciesSetCutoff(Var::abs_lines_per_species(ws).value(), option.value(), value.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetCutoffForMatch(

            Workspace& ws,

      const Var::String option,

      const Var::Numeric value,

      const Var::QuantumIdentifier ID) {

  abs_linesSetCutoffForMatch(Var::abs_lines(ws).value(), option.value(), value.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetCutoffForMatch(

            Workspace& ws,

      const Var::String option,

      const Var::Numeric value,

      const Var::QuantumIdentifier ID) {

  abs_lines_per_speciesSetCutoffForMatch(Var::abs_lines_per_species(ws).value(), option.value(), value.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetCutoffForSpecies(

            Workspace& ws,

      const Var::String option,

      const Var::Numeric value,

      const Var::String species_tag) {

  abs_lines_per_speciesSetCutoffForSpecies(Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), option.value(), value.value(), species_tag.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetLinemixingLimit(

            Workspace& ws,

      const Var::Numeric value) {

  abs_linesSetLinemixingLimit(Var::abs_lines(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetLinemixingLimit(

            Workspace& ws,

      const Var::Numeric value) {

  abs_lines_per_speciesSetLinemixingLimit(Var::abs_lines_per_species(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetLinemixingLimitForMatch(

            Workspace& ws,

      const Var::Numeric value,

      const Var::QuantumIdentifier ID) {

  abs_linesSetLinemixingLimitForMatch(Var::abs_lines(ws).value(), value.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetLinemixingLimitForMatch(

            Workspace& ws,

      const Var::Numeric value,

      const Var::QuantumIdentifier ID) {

  abs_lines_per_speciesSetLinemixingLimitForMatch(Var::abs_lines_per_species(ws).value(), value.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetLinemixingLimitForSpecies(

            Workspace& ws,

      const Var::Numeric value,

      const Var::String species_tag) {

  abs_lines_per_speciesSetLinemixingLimitForSpecies(Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), value.value(), species_tag.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetT0(

            Workspace& ws,

      const Var::Numeric value) {

  abs_linesSetT0(Var::abs_lines(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetT0(

            Workspace& ws,

      const Var::Numeric value) {

  abs_lines_per_speciesSetT0(Var::abs_lines_per_species(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetT0ForMatch(

            Workspace& ws,

      const Var::Numeric value,

      const Var::QuantumIdentifier ID) {

  abs_linesSetT0ForMatch(Var::abs_lines(ws).value(), value.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetT0ForMatch(

            Workspace& ws,

      const Var::Numeric value,

      const Var::QuantumIdentifier ID) {

  abs_lines_per_speciesSetT0ForMatch(Var::abs_lines_per_species(ws).value(), value.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetT0ForSpecies(

            Workspace& ws,

      const Var::Numeric value,

      const Var::String species_tag) {

  abs_lines_per_speciesSetT0ForSpecies(Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), value.value(), species_tag.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetQuantumNumberForMatch(

            Workspace& ws,

      const Var::String quantum_number,

      const Var::Rational value,

      const Var::QuantumIdentifier ID) {

  abs_linesSetQuantumNumberForMatch(Var::abs_lines(ws).value(), quantum_number.value(), value.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetQuantumNumberForMatch(

            Workspace& ws,

      const Var::String quantum_number,

      const Var::Rational value,

      const Var::QuantumIdentifier ID) {

  abs_lines_per_speciesSetQuantumNumberForMatch(Var::abs_lines_per_species(ws).value(), quantum_number.value(), value.value(), ID.value(), Var::verbosity(ws).value());

}


inline void abs_linesChangeBaseParameterForMatchingLevel(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter_name,

      const Var::Numeric change,

      const Var::Index relative=Group::Index{0}) {

  abs_linesChangeBaseParameterForMatchingLevel(Var::abs_lines(ws).value(), QI.value(), parameter_name.value(), change.value(), relative.value(), Var::verbosity(ws).value());

}


inline void abs_linesChangeBaseParameterForMatchingLevels(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier QI,

      const Var::String parameter_name,

      const Var::Vector change,

      const Var::Index relative=Group::Index{0}) {

  abs_linesChangeBaseParameterForMatchingLevels(Var::abs_lines(ws).value(), QI.value(), parameter_name.value(), change.value(), relative.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesChangeBaseParameterForMatchingLevel(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter_name,

      const Var::Numeric change,

      const Var::Index relative=Group::Index{0}) {

  abs_lines_per_speciesChangeBaseParameterForMatchingLevel(Var::abs_lines_per_species(ws).value(), QI.value(), parameter_name.value(), change.value(), relative.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesChangeBaseParameterForMatchingLevels(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier QI,

      const Var::String parameter_name,

      const Var::Vector change,

      const Var::Index relative=Group::Index{0}) {

  abs_lines_per_speciesChangeBaseParameterForMatchingLevels(Var::abs_lines_per_species(ws).value(), QI.value(), parameter_name.value(), change.value(), relative.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetBaseParameterForMatchingLevel(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter_name,

      const Var::Numeric change) {

  abs_linesSetBaseParameterForMatchingLevel(Var::abs_lines(ws).value(), QI.value(), parameter_name.value(), change.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetBaseParameterForMatchingLevels(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier QI,

      const Var::String parameter_name,

      const Var::Vector change) {

  abs_linesSetBaseParameterForMatchingLevels(Var::abs_lines(ws).value(), QI.value(), parameter_name.value(), change.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetBaseParameterForMatchingLevel(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter_name,

      const Var::Numeric change) {

  abs_lines_per_speciesSetBaseParameterForMatchingLevel(Var::abs_lines_per_species(ws).value(), QI.value(), parameter_name.value(), change.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetBaseParameterForMatchingLevels(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier QI,

      const Var::String parameter_name,

      const Var::Vector change) {

  abs_lines_per_speciesSetBaseParameterForMatchingLevels(Var::abs_lines_per_species(ws).value(), QI.value(), parameter_name.value(), change.value(), Var::verbosity(ws).value());

}


inline void abs_linesChangeBaseParameterForMatchingLines(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter_name,

      const Var::Numeric change,

      const Var::Index relative=Group::Index{0},

      const Var::Index loose_matching=Group::Index{0}) {

  abs_linesChangeBaseParameterForMatchingLines(Var::abs_lines(ws).value(), QI.value(), parameter_name.value(), change.value(), relative.value(), loose_matching.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesChangeBaseParameterForMatchingLines(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter_name,

      const Var::Numeric change,

      const Var::Index relative=Group::Index{0},

      const Var::Index loose_matching=Group::Index{0}) {

  abs_lines_per_speciesChangeBaseParameterForMatchingLines(Var::abs_lines_per_species(ws).value(), QI.value(), parameter_name.value(), change.value(), relative.value(), loose_matching.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesChangeBaseParameterForSpecies(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter_name,

      const Var::Numeric change,

      const Var::String species_tag,

      const Var::Index relative=Group::Index{0},

      const Var::Index loose_matching=Group::Index{0}) {

  abs_lines_per_speciesChangeBaseParameterForSpecies(Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), QI.value(), parameter_name.value(), change.value(), relative.value(), loose_matching.value(), species_tag.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetBaseParameterForMatchingLines(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter_name,

      const Var::Numeric change,

      const Var::Index loose_matching=Group::Index{0}) {

  abs_linesSetBaseParameterForMatchingLines(Var::abs_lines(ws).value(), QI.value(), parameter_name.value(), change.value(), loose_matching.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetBaseParameterForMatchingLines(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter_name,

      const Var::Numeric change,

      const Var::Index loose_matching=Group::Index{0}) {

  abs_lines_per_speciesSetBaseParameterForMatchingLines(Var::abs_lines_per_species(ws).value(), QI.value(), parameter_name.value(), change.value(), loose_matching.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetBaseParameterForSpecies(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter_name,

      const Var::Numeric change,

      const Var::String species_tag,

      const Var::Index loose_matching=Group::Index{0}) {

  abs_lines_per_speciesSetBaseParameterForSpecies(Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), QI.value(), parameter_name.value(), change.value(), loose_matching.value(), species_tag.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetLineShapeModelParameterForMatchingLines(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter,

      const Var::String coefficient,

      const Var::String species,

      const Var::Numeric change) {

  abs_linesSetLineShapeModelParameterForMatchingLines(Var::abs_lines(ws).value(), QI.value(), parameter.value(), coefficient.value(), species.value(), change.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetLineShapeModelParameterForMatchingLines(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter,

      const Var::String coefficient,

      const Var::String species,

      const Var::Numeric change) {

  abs_lines_per_speciesSetLineShapeModelParameterForMatchingLines(Var::abs_lines_per_species(ws).value(), QI.value(), parameter.value(), coefficient.value(), species.value(), change.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetLineShapeModelParameterForSpecies(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter,

      const Var::String coefficient,

      const Var::String species,

      const Var::Numeric change,

      const Var::String species_tag) {

  abs_lines_per_speciesSetLineShapeModelParameterForSpecies(Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), QI.value(), parameter.value(), coefficient.value(), species.value(), change.value(), species_tag.value(), Var::verbosity(ws).value());

}


inline void abs_linesSetZeemanCoefficients(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier qid,

      const Var::Vector gs) {

  abs_linesSetZeemanCoefficients(Var::abs_lines(ws).value(), qid.value(), gs.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesSetZeemanCoefficients(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier qid,

      const Var::Vector gs) {

  abs_lines_per_speciesSetZeemanCoefficients(Var::abs_lines_per_species(ws).value(), qid.value(), gs.value(), Var::verbosity(ws).value());

}


inline void abs_linesChangeLineShapeModelParameterForMatchingLines(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter,

      const Var::String coefficient,

      const Var::String species,

      const Var::Numeric change,

      const Var::Index relative=Group::Index{0}) {

  abs_linesChangeLineShapeModelParameterForMatchingLines(Var::abs_lines(ws).value(), QI.value(), parameter.value(), coefficient.value(), species.value(), change.value(), relative.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesChangeLineShapeModelParameterForMatchingLines(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter,

      const Var::String coefficient,

      const Var::String species,

      const Var::Numeric change,

      const Var::Index relative=Group::Index{0}) {

  abs_lines_per_speciesChangeLineShapeModelParameterForMatchingLines(Var::abs_lines_per_species(ws).value(), QI.value(), parameter.value(), coefficient.value(), species.value(), change.value(), relative.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesChangeLineShapeModelParameterForSpecies(

            Workspace& ws,

      const Var::QuantumIdentifier QI,

      const Var::String parameter,

      const Var::String coefficient,

      const Var::String species,

      const Var::Numeric change,

      const Var::String species_tag,

      const Var::Index relative=Group::Index{0}) {

  abs_lines_per_speciesChangeLineShapeModelParameterForSpecies(Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), QI.value(), parameter.value(), coefficient.value(), species.value(), change.value(), relative.value(), species_tag.value(), Var::verbosity(ws).value());

}


inline void abs_linesCompact(

            Workspace& ws) {

  abs_linesCompact(Var::abs_lines(ws).value(), Var::f_grid(ws).value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesCompact(

            Workspace& ws) {

  abs_lines_per_speciesCompact(Var::abs_lines_per_species(ws).value(), Var::f_grid(ws).value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesCreateFromLines(

            Workspace& ws) {

  abs_lines_per_speciesCreateFromLines(Var::abs_lines_per_species(ws).value(), Var::abs_lines(ws).value(), Var::abs_species(ws).value(), Var::verbosity(ws).value());

}


inline void abs_lookupAdapt(

            Workspace& ws) {

  abs_lookupAdapt(Var::abs_lookup(ws).value(), Var::abs_lookup_is_adapted(ws).value(), Var::abs_species(ws).value(), Var::f_grid(ws).value(), Var::verbosity(ws).value());

}


inline void abs_lookupCalc(

            Workspace& ws) {

  abs_lookupCalc(ws, Var::abs_lookup(ws).value(), Var::abs_lookup_is_adapted(ws).value(), Var::abs_species(ws).value(), Var::abs_nls(ws).value(), Var::f_grid(ws).value(), Var::abs_p(ws).value(), Var::abs_vmrs(ws).value(), Var::abs_t(ws).value(), Var::abs_t_pert(ws).value(), Var::abs_nls_pert(ws).value(), Var::abs_xsec_agenda(ws).value(), Var::verbosity(ws).value());

}


inline void abs_lookupInit(

            Workspace& ws) {

  abs_lookupInit(Var::abs_lookup(ws).value(), Var::verbosity(ws).value());

}


inline void abs_lookupSetup(

            Workspace& ws,

      const Var::Numeric p_step=Group::Numeric{0.05},

      const Var::Numeric t_step=Group::Numeric{100},

      const Var::Numeric h2o_step=Group::Numeric{100}) {

  abs_lookupSetup(Var::abs_p(ws).value(), Var::abs_t(ws).value(), Var::abs_t_pert(ws).value(), Var::abs_vmrs(ws).value(), Var::abs_nls(ws).value(), Var::abs_nls_pert(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::t_field(ws).value(), Var::vmr_field(ws).value(), Var::atmfields_checked(ws).value(), Var::abs_species(ws).value(), Var::abs_p_interp_order(ws).value(), Var::abs_t_interp_order(ws).value(), Var::abs_nls_interp_order(ws).value(), p_step.value(), t_step.value(), h2o_step.value(), Var::verbosity(ws).value());

}


inline void abs_lookupSetupBatch(

            Workspace& ws,

      const Var::Numeric p_step=Group::Numeric{0.05},

      const Var::Numeric t_step=Group::Numeric{20},

      const Var::Numeric h2o_step=Group::Numeric{100},

      const Var::Vector extremes=Group::Vector{},

      const Var::Index robust=Group::Index{0},

      const Var::Index check_gridnames=Group::Index{0}) {

  abs_lookupSetupBatch(Var::abs_p(ws).value(), Var::abs_t(ws).value(), Var::abs_t_pert(ws).value(), Var::abs_vmrs(ws).value(), Var::abs_nls(ws).value(), Var::abs_nls_pert(ws).value(), Var::abs_species(ws).value(), Var::batch_atm_fields_compact(ws).value(), Var::abs_p_interp_order(ws).value(), Var::abs_t_interp_order(ws).value(), Var::abs_nls_interp_order(ws).value(), Var::atmosphere_dim(ws).value(), p_step.value(), t_step.value(), h2o_step.value(), extremes.value(), robust.value(), check_gridnames.value(), Var::verbosity(ws).value());

}


inline void abs_lookupSetupWide(

            Workspace& ws,

      const Var::Numeric p_min=Group::Numeric{0.5},

      const Var::Numeric p_max=Group::Numeric{110000},

      const Var::Numeric p_step=Group::Numeric{0.05},

      const Var::Numeric t_min=Group::Numeric{100},

      const Var::Numeric t_max=Group::Numeric{400},

      const Var::Numeric h2o_min=Group::Numeric{0},

      const Var::Numeric h2o_max=Group::Numeric{0.05}) {

  abs_lookupSetupWide(Var::abs_p(ws).value(), Var::abs_t(ws).value(), Var::abs_t_pert(ws).value(), Var::abs_vmrs(ws).value(), Var::abs_nls(ws).value(), Var::abs_nls_pert(ws).value(), Var::abs_species(ws).value(), Var::abs_p_interp_order(ws).value(), Var::abs_t_interp_order(ws).value(), Var::abs_nls_interp_order(ws).value(), p_min.value(), p_max.value(), p_step.value(), t_min.value(), t_max.value(), h2o_min.value(), h2o_max.value(), Var::verbosity(ws).value());

}


inline void abs_lookupTestAccuracy(

            Workspace& ws) {

  abs_lookupTestAccuracy(ws, Var::abs_lookup(ws).value(), Var::abs_lookup_is_adapted(ws).value(), Var::abs_p_interp_order(ws).value(), Var::abs_t_interp_order(ws).value(), Var::abs_nls_interp_order(ws).value(), Var::abs_xsec_agenda(ws).value(), Var::verbosity(ws).value());

}


inline void abs_lookupTestAccMC(

            Workspace& ws) {

  abs_lookupTestAccMC(ws, Var::abs_lookup(ws).value(), Var::abs_lookup_is_adapted(ws).value(), Var::abs_p_interp_order(ws).value(), Var::abs_t_interp_order(ws).value(), Var::abs_nls_interp_order(ws).value(), Var::mc_seed(ws).value(), Var::abs_xsec_agenda(ws).value(), Var::verbosity(ws).value());

}


inline void abs_nlteFromRaw(

            Workspace& ws,

      const Var::Matrix data) {

  abs_nlteFromRaw(Var::abs_nlte(ws).value(), Var::nlte_level_identifiers(ws).value(), Var::nlte_vibrational_energies(ws).value(), data.value(), Var::verbosity(ws).value());

}


inline void abs_speciesAdd(

            Workspace& ws,

      const Var::ArrayOfString species) {

  abs_speciesAdd(Var::abs_species(ws).value(), Var::propmat_clearsky_agenda_checked(ws).value(), Var::abs_xsec_agenda_checked(ws).value(), species.value(), Var::verbosity(ws).value());

}


inline void abs_speciesAdd2(

            Workspace& ws,

      const Var::Vector gin1,

      const Var::Vector gin2,

      const Var::Vector gin3,

      const Var::String species,

      const Var::String unit=Group::String{"vmr"}) {

  abs_speciesAdd2(ws, Var::abs_species(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::propmat_clearsky_agenda_checked(ws).value(), Var::abs_xsec_agenda_checked(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), gin1.value(), gin2.value(), gin3.value(), species.value(), unit.value(), Var::verbosity(ws).value());

}


inline void abs_speciesDefineAllInScenario(

            Workspace& ws,

      const Var::String basename) {

  abs_speciesDefineAllInScenario(Var::abs_species(ws).value(), Var::propmat_clearsky_agenda_checked(ws).value(), Var::abs_xsec_agenda_checked(ws).value(), basename.value(), Var::verbosity(ws).value());

}


inline void abs_speciesDefineAll(

            Workspace& ws) {

  abs_speciesDefineAll(Var::abs_species(ws).value(), Var::propmat_clearsky_agenda_checked(ws).value(), Var::abs_xsec_agenda_checked(ws).value(), Var::verbosity(ws).value());

}


inline void abs_speciesInit(

            Workspace& ws) {

  abs_speciesInit(Var::abs_species(ws).value(), Var::verbosity(ws).value());

}


inline void abs_speciesSet(

            Workspace& ws,

      const Var::ArrayOfString species) {

  abs_speciesSet(Var::abs_species(ws).value(), Var::abs_xsec_agenda_checked(ws).value(), Var::propmat_clearsky_agenda_checked(ws).value(), species.value(), Var::verbosity(ws).value());

}


inline void abs_vecAddGas(

            Workspace& ws) {

  abs_vecAddGas(Var::abs_vec(ws).value(), Var::propmat_clearsky(ws).value(), Var::verbosity(ws).value());

}


inline void abs_xsec_agenda_checkedCalc(

            Workspace& ws) {

  abs_xsec_agenda_checkedCalc(ws, Var::abs_xsec_agenda_checked(ws).value(), Var::abs_species(ws).value(), Var::abs_xsec_agenda(ws).value(), Var::verbosity(ws).value());

}


inline void abs_xsec_per_speciesAddCIA(

            Workspace& ws,

      const Var::Numeric T_extrapolfac=Group::Numeric{0.5},

      const Var::Index robust=Group::Index{0}) {

  abs_xsec_per_speciesAddCIA(Var::abs_xsec_per_species(ws).value(), Var::dabs_xsec_per_species_dx(ws).value(), Var::abs_species(ws).value(), Var::jacobian_quantities(ws).value(), Var::abs_species_active(ws).value(), Var::f_grid(ws).value(), Var::abs_p(ws).value(), Var::abs_t(ws).value(), Var::abs_vmrs(ws).value(), Var::abs_cia_data(ws).value(), T_extrapolfac.value(), robust.value(), Var::verbosity(ws).value());

}


inline void abs_xsec_per_speciesAddHitranXsec(

            Workspace& ws,

      const Var::Index apply_tfit=Group::Index{1},

      const Var::Numeric force_p=Group::Numeric{-1},

      const Var::Numeric force_t=Group::Numeric{-1}) {

  abs_xsec_per_speciesAddHitranXsec(Var::abs_xsec_per_species(ws).value(), Var::dabs_xsec_per_species_dx(ws).value(), Var::abs_species(ws).value(), Var::jacobian_quantities(ws).value(), Var::abs_species_active(ws).value(), Var::f_grid(ws).value(), Var::abs_p(ws).value(), Var::abs_t(ws).value(), Var::hitran_xsec_data(ws).value(), apply_tfit.value(), force_p.value(), force_t.value(), Var::verbosity(ws).value());

}


inline void abs_xsec_per_speciesAddConts(

            Workspace& ws) {

  abs_xsec_per_speciesAddConts(Var::abs_xsec_per_species(ws).value(), Var::dabs_xsec_per_species_dx(ws).value(), Var::abs_species(ws).value(), Var::jacobian_quantities(ws).value(), Var::abs_species_active(ws).value(), Var::f_grid(ws).value(), Var::abs_p(ws).value(), Var::abs_t(ws).value(), Var::abs_vmrs(ws).value(), Var::abs_cont_names(ws).value(), Var::abs_cont_parameters(ws).value(), Var::abs_cont_models(ws).value(), Var::verbosity(ws).value());

}


inline void abs_xsec_per_speciesAddLines(

            Workspace& ws) {

  abs_xsec_per_speciesAddLines(Var::abs_xsec_per_species(ws).value(), Var::src_xsec_per_species(ws).value(), Var::dabs_xsec_per_species_dx(ws).value(), Var::dsrc_xsec_per_species_dx(ws).value(), Var::abs_species(ws).value(), Var::jacobian_quantities(ws).value(), Var::abs_species_active(ws).value(), Var::f_grid(ws).value(), Var::abs_p(ws).value(), Var::abs_t(ws).value(), Var::abs_nlte(ws).value(), Var::abs_vmrs(ws).value(), Var::abs_lines_per_species(ws).value(), Var::isotopologue_ratios(ws).value(), Var::partition_functions(ws).value(), Var::lbl_checked(ws).value(), Var::verbosity(ws).value());

}


inline void abs_xsec_per_speciesAddPredefinedO2MPM2020(

            Workspace& ws) {

  abs_xsec_per_speciesAddPredefinedO2MPM2020(Var::abs_xsec_per_species(ws).value(), Var::dabs_xsec_per_species_dx(ws).value(), Var::abs_species(ws).value(), Var::jacobian_quantities(ws).value(), Var::f_grid(ws).value(), Var::abs_p(ws).value(), Var::abs_t(ws).value(), Var::abs_vmrs(ws).value(), Var::verbosity(ws).value());

}


inline void abs_xsec_per_speciesInit(

            Workspace& ws) {

  abs_xsec_per_speciesInit(Var::abs_xsec_per_species(ws).value(), Var::src_xsec_per_species(ws).value(), Var::dabs_xsec_per_species_dx(ws).value(), Var::dsrc_xsec_per_species_dx(ws).value(), Var::abs_species(ws).value(), Var::jacobian_quantities(ws).value(), Var::abs_species_active(ws).value(), Var::f_grid(ws).value(), Var::abs_p(ws).value(), Var::abs_xsec_agenda_checked(ws).value(), Var::nlte_do(ws).value(), Var::verbosity(ws).value());

}


inline void AddZaAa(

            Workspace& ws,

            Var::Matrix new_los,

      const Var::Vector ref_los,

      const Var::Matrix dlos) {

  if (new_los.islast()) {

    throw std::runtime_error("new_los needs to be a defined WorkspaceMatrix since it is output of AddZaAa");

  }


  AddZaAa(new_los.value(), ref_los.value(), dlos.value(), Var::verbosity(ws).value());

}


inline void AgendaExecute(

            Workspace& ws,

      const Var::Agenda a) {

  AgendaExecute(ws, a.value(), Var::verbosity(ws).value());

}


inline void AgendaExecuteExclusive(

            Workspace& ws,

      const Var::Agenda a) {

  AgendaExecuteExclusive(ws, a.value(), Var::verbosity(ws).value());

}


inline void AngularGridsSetFluxCalc(

            Workspace& ws,

      const Var::Index N_za_grid=Group::Index{2},

      const Var::Index N_aa_grid=Group::Index{1},

      const Var::String za_grid_type=Group::String{"linear_mu"}) {

  AngularGridsSetFluxCalc(Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::za_grid_weights(ws).value(), N_za_grid.value(), N_aa_grid.value(), za_grid_type.value(), Var::verbosity(ws).value());

}


inline void ArrayOfAgendaExecute(

            Workspace& ws,

      const Var::ArrayOfAgenda agendas) {

  ArrayOfAgendaExecute(ws, Var::agenda_array_index(ws).value(), agendas.value(), Var::verbosity(ws).value());

}


inline void AntennaConstantGaussian1D(

            Workspace& ws,

      const Var::Index n_za_grid,

      const Var::Numeric fwhm,

      const Var::Numeric xwidth_si=Group::Numeric{3},

      const Var::Numeric dx_si=Group::Numeric{0.1}) {

  AntennaConstantGaussian1D(Var::antenna_dim(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::antenna_response(ws).value(), Var::antenna_dlos(ws).value(), n_za_grid.value(), fwhm.value(), xwidth_si.value(), dx_si.value(), Var::verbosity(ws).value());

}


inline void AntennaMultiBeamsToPencilBeams(

            Workspace& ws) {

  AntennaMultiBeamsToPencilBeams(Var::sensor_pos(ws).value(), Var::sensor_los(ws).value(), Var::antenna_dlos(ws).value(), Var::antenna_dim(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::verbosity(ws).value());

}


inline void AntennaOff(

            Workspace& ws) {

  AntennaOff(Var::antenna_dim(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::verbosity(ws).value());

}


inline void antenna_responseGaussian(

            Workspace& ws,

      const Var::Numeric fwhm,

      const Var::Numeric xwidth_si=Group::Numeric{3},

      const Var::Numeric dx_si=Group::Numeric{0.1},

      const Var::Index do_2d=Group::Index{0}) {

  antenna_responseGaussian(Var::antenna_response(ws).value(), fwhm.value(), xwidth_si.value(), dx_si.value(), do_2d.value(), Var::verbosity(ws).value());

}


inline void antenna_responseVaryingGaussian(

            Workspace& ws,

      const Var::Numeric leff,

      const Var::Index nf,

      const Var::Numeric fstart,

      const Var::Numeric fstop,

      const Var::Numeric xwidth_si=Group::Numeric{3},

      const Var::Numeric dx_si=Group::Numeric{0.1},

      const Var::Index do_2d=Group::Index{0}) {

  antenna_responseVaryingGaussian(Var::antenna_response(ws).value(), leff.value(), xwidth_si.value(), dx_si.value(), nf.value(), fstart.value(), fstop.value(), do_2d.value(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::Vector out,

      const Var::Numeric in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::Vector out,

      const Var::Vector in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::Matrix out,

      const Var::Matrix in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::Matrix out,

      const Var::Vector in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::Tensor3 out,

      const Var::Matrix in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::Tensor3 out,

      const Var::Tensor3 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::Tensor4 out,

      const Var::Tensor3 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::Tensor4 out,

      const Var::Tensor4 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::String out,

      const Var::String in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceString since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfAbsorptionLines out,

      const Var::ArrayOfAbsorptionLines in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAbsorptionLines since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfAbsorptionLines out,

      const Var::ArrayOfArrayOfAbsorptionLines in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfAgenda out,

      const Var::ArrayOfAgenda in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAgenda since it is output of Append");

  }


  Append(ws, out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField1 out,

      const Var::ArrayOfArrayOfGriddedField1 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField2 out,

      const Var::ArrayOfArrayOfGriddedField2 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField3 out,

      const Var::ArrayOfArrayOfGriddedField3 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfIndex out,

      const Var::ArrayOfArrayOfIndex in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfIndex since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfMatrix out,

      const Var::ArrayOfArrayOfMatrix in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfPpath out,

      const Var::ArrayOfPpath in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPpath since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfPropagationMatrix out,

      const Var::ArrayOfArrayOfPropagationMatrix in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfRadiationVector out,

      const Var::ArrayOfArrayOfRadiationVector in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfScatteringMetaData out,

      const Var::ArrayOfArrayOfScatteringMetaData in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfSingleScatteringData out,

      const Var::ArrayOfArrayOfSingleScatteringData in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfSpeciesTag out,

      const Var::ArrayOfArrayOfSpeciesTag in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfStokesVector out,

      const Var::ArrayOfArrayOfStokesVector in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfString out,

      const Var::ArrayOfArrayOfString in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfString since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfTensor3 out,

      const Var::ArrayOfArrayOfTensor3 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfTensor6 out,

      const Var::ArrayOfArrayOfTensor6 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfTime out,

      const Var::ArrayOfArrayOfTime in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTime since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfTransmissionMatrix out,

      const Var::ArrayOfArrayOfTransmissionMatrix in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfVector out,

      const Var::ArrayOfArrayOfVector in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfVector since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfCIARecord out,

      const Var::ArrayOfCIARecord in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfCIARecord since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfGriddedField1 out,

      const Var::ArrayOfGriddedField1 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField1 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfGriddedField2 out,

      const Var::ArrayOfGriddedField2 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField2 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfGriddedField3 out,

      const Var::ArrayOfGriddedField3 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfGriddedField4 out,

      const Var::ArrayOfGriddedField4 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField4 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfIndex out,

      const Var::ArrayOfIndex in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfMatrix out,

      const Var::ArrayOfMatrix in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfMatrix since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfPropagationMatrix out,

      const Var::ArrayOfPropagationMatrix in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPropagationMatrix since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfQuantumIdentifier out,

      const Var::ArrayOfQuantumIdentifier in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfRadiationVector out,

      const Var::ArrayOfRadiationVector in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRadiationVector since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfRetrievalQuantity out,

      const Var::ArrayOfRetrievalQuantity in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfScatteringMetaData out,

      const Var::ArrayOfScatteringMetaData in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfScatteringMetaData since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfSingleScatteringData out,

      const Var::ArrayOfSingleScatteringData in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfSparse out,

      const Var::ArrayOfSparse in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSparse since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfStokesVector out,

      const Var::ArrayOfStokesVector in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfStokesVector since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfString out,

      const Var::ArrayOfString in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfString since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTelsemAtlas out,

      const Var::ArrayOfTelsemAtlas in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTelsemAtlas since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTensor3 out,

      const Var::ArrayOfTensor3 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor3 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTensor4 out,

      const Var::ArrayOfTensor4 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor4 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTensor5 out,

      const Var::ArrayOfTensor5 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor5 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTensor6 out,

      const Var::ArrayOfTensor6 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor6 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTensor7 out,

      const Var::ArrayOfTensor7 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor7 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTime out,

      const Var::ArrayOfTime in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTime since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTransmissionMatrix out,

      const Var::ArrayOfTransmissionMatrix in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfVector out,

      const Var::ArrayOfVector in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfXsecRecord out,

      const Var::ArrayOfXsecRecord in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfXsecRecord since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfAbsorptionLines out,

      const Var::AbsorptionLines in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAbsorptionLines since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfAbsorptionLines out,

      const Var::ArrayOfAbsorptionLines in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfAgenda out,

      const Var::Agenda in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAgenda since it is output of Append");

  }


  Append(ws, out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField1 out,

      const Var::ArrayOfGriddedField1 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField2 out,

      const Var::ArrayOfGriddedField2 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField3 out,

      const Var::ArrayOfGriddedField3 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfIndex out,

      const Var::ArrayOfIndex in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfIndex since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfMatrix out,

      const Var::ArrayOfMatrix in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfPpath out,

      const Var::Ppath in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPpath since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfPropagationMatrix out,

      const Var::ArrayOfPropagationMatrix in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfRadiationVector out,

      const Var::ArrayOfRadiationVector in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfScatteringMetaData out,

      const Var::ArrayOfScatteringMetaData in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfSingleScatteringData out,

      const Var::ArrayOfSingleScatteringData in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfStokesVector out,

      const Var::ArrayOfStokesVector in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfString out,

      const Var::ArrayOfString in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfString since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfTensor3 out,

      const Var::ArrayOfTensor3 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfTensor6 out,

      const Var::ArrayOfTensor6 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfTime out,

      const Var::ArrayOfTime in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTime since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfTransmissionMatrix out,

      const Var::ArrayOfTransmissionMatrix in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfArrayOfVector out,

      const Var::ArrayOfVector in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfVector since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfCIARecord out,

      const Var::CIARecord in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfCIARecord since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfGriddedField1 out,

      const Var::GriddedField1 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField1 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfGriddedField2 out,

      const Var::GriddedField2 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField2 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfGriddedField3 out,

      const Var::GriddedField3 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfGriddedField4 out,

      const Var::GriddedField4 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField4 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfIndex out,

      const Var::Index in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfMatrix out,

      const Var::Matrix in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfMatrix since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfPropagationMatrix out,

      const Var::PropagationMatrix in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPropagationMatrix since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfQuantumIdentifier out,

      const Var::QuantumIdentifier in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfRadiationVector out,

      const Var::RadiationVector in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRadiationVector since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfScatteringMetaData out,

      const Var::ScatteringMetaData in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfScatteringMetaData since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfSingleScatteringData out,

      const Var::SingleScatteringData in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfSparse out,

      const Var::Sparse in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSparse since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfStokesVector out,

      const Var::StokesVector in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfStokesVector since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfString out,

      const Var::String in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfString since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTelsemAtlas out,

      const Var::TelsemAtlas in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTelsemAtlas since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTensor3 out,

      const Var::Tensor3 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor3 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTensor4 out,

      const Var::Tensor4 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor4 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTensor5 out,

      const Var::Tensor5 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor5 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTensor6 out,

      const Var::Tensor6 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor6 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTensor7 out,

      const Var::Tensor7 in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor7 since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTime out,

      const Var::Time in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTime since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfTransmissionMatrix out,

      const Var::TransmissionMatrix in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void Append(

            Workspace& ws,

            Var::ArrayOfVector out,

      const Var::Vector in,

      const Var::String dimension=Group::String{"leading"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of Append");

  }


  Append(out.value(), out.name(), in.value(), dimension.value(), in.islast() ? Group::String{"in"} : in.name(), dimension.islast() ? Group::String{"dimension"} : dimension.name(), Var::verbosity(ws).value());

}


inline void ArrayOfGriddedFieldGetNames(

            Workspace& ws,

            Var::ArrayOfString names,

      const Var::ArrayOfGriddedField1 griddedfields) {

  if (names.islast()) {

    throw std::runtime_error("names needs to be a defined WorkspaceArrayOfString since it is output of ArrayOfGriddedFieldGetNames");

  }


  ArrayOfGriddedFieldGetNames(names.value(), griddedfields.value(), Var::verbosity(ws).value());

}


inline void ArrayOfGriddedFieldGetNames(

            Workspace& ws,

            Var::ArrayOfString names,

      const Var::ArrayOfGriddedField2 griddedfields) {

  if (names.islast()) {

    throw std::runtime_error("names needs to be a defined WorkspaceArrayOfString since it is output of ArrayOfGriddedFieldGetNames");

  }


  ArrayOfGriddedFieldGetNames(names.value(), griddedfields.value(), Var::verbosity(ws).value());

}


inline void ArrayOfGriddedFieldGetNames(

            Workspace& ws,

            Var::ArrayOfString names,

      const Var::ArrayOfGriddedField3 griddedfields) {

  if (names.islast()) {

    throw std::runtime_error("names needs to be a defined WorkspaceArrayOfString since it is output of ArrayOfGriddedFieldGetNames");

  }


  ArrayOfGriddedFieldGetNames(names.value(), griddedfields.value(), Var::verbosity(ws).value());

}


inline void ArrayOfGriddedFieldGetNames(

            Workspace& ws,

            Var::ArrayOfString names,

      const Var::ArrayOfGriddedField4 griddedfields) {

  if (names.islast()) {

    throw std::runtime_error("names needs to be a defined WorkspaceArrayOfString since it is output of ArrayOfGriddedFieldGetNames");

  }


  ArrayOfGriddedFieldGetNames(names.value(), griddedfields.value(), Var::verbosity(ws).value());

}


inline void ArrayOfIndexLinSpace(

            Workspace& ws,

            Var::ArrayOfIndex out,

      const Var::Index start,

      const Var::Index stop,

      const Var::Index step) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of ArrayOfIndexLinSpace");

  }


  ArrayOfIndexLinSpace(out.value(), start.value(), stop.value(), step.value(), Var::verbosity(ws).value());

}


inline void ArrayOfIndexSet(

            Workspace& ws,

            Var::ArrayOfIndex out,

      const Var::ArrayOfIndex value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of ArrayOfIndexSet");

  }


  ArrayOfIndexSet(out.value(), value.value(), Var::verbosity(ws).value());

}


inline void ArrayOfIndexSetConstant(

            Workspace& ws,

            Var::ArrayOfIndex out,

      const Var::Index value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of ArrayOfIndexSetConstant");

  }


  ArrayOfIndexSetConstant(out.value(), Var::nelem(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void ArrayOfStringSet(

            Workspace& ws,

            Var::ArrayOfString out,

      const Var::ArrayOfString value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfString since it is output of ArrayOfStringSet");

  }


  ArrayOfStringSet(out.value(), value.value(), Var::verbosity(ws).value());

}


inline void AtmFieldPerturb(

            Workspace& ws,

            Var::Tensor3 perturbed_field,

      const Var::Tensor3 original_field,

      const Var::Vector p_ret_grid,

      const Var::Vector lat_ret_grid,

      const Var::Vector lon_ret_grid,

      const Var::Index pert_index,

      const Var::Numeric pert_size,

      const Var::String pert_mode=Group::String{"absolute"}) {

  if (perturbed_field.islast()) {

    throw std::runtime_error("perturbed_field needs to be a defined WorkspaceTensor3 since it is output of AtmFieldPerturb");

  }


  AtmFieldPerturb(perturbed_field.value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), original_field.value(), p_ret_grid.value(), lat_ret_grid.value(), lon_ret_grid.value(), pert_index.value(), pert_size.value(), pert_mode.value(), Var::verbosity(ws).value());

}


inline void AtmFieldPerturbAtmGrids(

            Workspace& ws,

            Var::Tensor3 perturbed_field,

      const Var::Tensor3 original_field,

      const Var::Index pert_index,

      const Var::Numeric pert_size,

      const Var::String pert_mode=Group::String{"absolute"}) {

  if (perturbed_field.islast()) {

    throw std::runtime_error("perturbed_field needs to be a defined WorkspaceTensor3 since it is output of AtmFieldPerturbAtmGrids");

  }


  AtmFieldPerturbAtmGrids(perturbed_field.value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), original_field.value(), pert_index.value(), pert_size.value(), pert_mode.value(), Var::verbosity(ws).value());

}


inline void AtmFieldPRegrid(

            Workspace& ws,

            Var::Tensor3 out,

      const Var::Tensor3 in,

      const Var::Vector p_grid_new,

      const Var::Vector p_grid_old,

      const Var::Index interp_order=Group::Index{1}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of AtmFieldPRegrid");

  }


  AtmFieldPRegrid(out.value(), in.value(), p_grid_new.value(), p_grid_old.value(), interp_order.value(), Var::verbosity(ws).value());

}


inline void AtmFieldPRegrid(

            Workspace& ws,

            Var::Tensor4 out,

      const Var::Tensor4 in,

      const Var::Vector p_grid_new,

      const Var::Vector p_grid_old,

      const Var::Index interp_order=Group::Index{1}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of AtmFieldPRegrid");

  }


  AtmFieldPRegrid(out.value(), in.value(), p_grid_new.value(), p_grid_old.value(), interp_order.value(), Var::verbosity(ws).value());

}


inline void AtmFieldsCalc(

            Workspace& ws,

      const Var::Index interp_order=Group::Index{1},

      const Var::Index vmr_zeropadding=Group::Index{0},

      const Var::Index vmr_nonegative=Group::Index{0},

      const Var::Index nlte_when_negative=Group::Index{0}) {

  AtmFieldsCalc(Var::t_field(ws).value(), Var::z_field(ws).value(), Var::vmr_field(ws).value(), Var::nlte_field(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::t_field_raw(ws).value(), Var::z_field_raw(ws).value(), Var::vmr_field_raw(ws).value(), Var::nlte_field_raw(ws).value(), Var::nlte_level_identifiers(ws).value(), Var::nlte_vibrational_energies(ws).value(), Var::atmosphere_dim(ws).value(), interp_order.value(), vmr_zeropadding.value(), vmr_nonegative.value(), nlte_when_negative.value(), Var::verbosity(ws).value());

}


inline void AtmFieldsCalcExpand1D(

            Workspace& ws,

      const Var::Index interp_order=Group::Index{1},

      const Var::Index vmr_zeropadding=Group::Index{0},

      const Var::Index vmr_nonegative=Group::Index{0},

      const Var::Index nlte_when_negative=Group::Index{0}) {

  AtmFieldsCalcExpand1D(Var::t_field(ws).value(), Var::z_field(ws).value(), Var::vmr_field(ws).value(), Var::nlte_field(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::t_field_raw(ws).value(), Var::z_field_raw(ws).value(), Var::vmr_field_raw(ws).value(), Var::nlte_field_raw(ws).value(), Var::nlte_level_identifiers(ws).value(), Var::nlte_vibrational_energies(ws).value(), Var::atmosphere_dim(ws).value(), interp_order.value(), vmr_zeropadding.value(), vmr_nonegative.value(), nlte_when_negative.value(), Var::verbosity(ws).value());

}


inline void AtmFieldsExpand1D(

            Workspace& ws,

      const Var::Index chk_vmr_nan=Group::Index{1}) {

  AtmFieldsExpand1D(Var::t_field(ws).value(), Var::z_field(ws).value(), Var::vmr_field(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::atmosphere_dim(ws).value(), chk_vmr_nan.value(), Var::verbosity(ws).value());

}


inline void AtmFieldsExtract1D(

            Workspace& ws,

      const Var::Index ilat=Group::Index{0},

      const Var::Index ilon=Group::Index{0}) {

  AtmFieldsExtract1D(Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::t_field(ws).value(), Var::z_field(ws).value(), Var::vmr_field(ws).value(), ilat.value(), ilon.value(), Var::verbosity(ws).value());

}


inline void AtmFieldsRefinePgrid(

            Workspace& ws,

      const Var::Numeric p_step,

      const Var::Index interp_order=Group::Index{1}) {

  AtmFieldsRefinePgrid(Var::p_grid(ws).value(), Var::t_field(ws).value(), Var::z_field(ws).value(), Var::vmr_field(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::cloudbox_checked(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::atmosphere_dim(ws).value(), p_step.value(), interp_order.value(), Var::verbosity(ws).value());

}


inline void AtmFieldsAndParticleBulkPropFieldFromCompact(

            Workspace& ws,

      const Var::String delim=Group::String{"-"},

      const Var::Numeric p_min=Group::Numeric{0},

      const Var::Index check_gridnames=Group::Index{0}) {

  AtmFieldsAndParticleBulkPropFieldFromCompact(Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::t_field(ws).value(), Var::z_field(ws).value(), Var::vmr_field(ws).value(), Var::particle_bulkprop_field(ws).value(), Var::particle_bulkprop_names(ws).value(), Var::abs_species(ws).value(), Var::atm_fields_compact(ws).value(), Var::atmosphere_dim(ws).value(), delim.value(), p_min.value(), check_gridnames.value(), Var::verbosity(ws).value());

}


inline void atmfields_checkedCalc(

            Workspace& ws,

      const Var::Index negative_vmr_ok=Group::Index{0},

      const Var::Index bad_partition_functions_ok=Group::Index{0}) {

  atmfields_checkedCalc(Var::atmfields_checked(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::abs_species(ws).value(), Var::t_field(ws).value(), Var::vmr_field(ws).value(), Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::partition_functions(ws).value(), Var::abs_f_interp_order(ws).value(), negative_vmr_ok.value(), bad_partition_functions_ok.value(), Var::verbosity(ws).value());

}


inline void atmgeom_checkedCalc(

            Workspace& ws) {

  atmgeom_checkedCalc(Var::atmgeom_checked(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::refellipsoid(ws).value(), Var::z_surface(ws).value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), Var::verbosity(ws).value());

}


inline void AtmosphereSet1D(

            Workspace& ws) {

  AtmosphereSet1D(Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::verbosity(ws).value());

}


inline void AtmosphereSet2D(

            Workspace& ws) {

  AtmosphereSet2D(Var::atmosphere_dim(ws).value(), Var::lon_grid(ws).value(), Var::verbosity(ws).value());

}


inline void AtmosphereSet3D(

            Workspace& ws) {

  AtmosphereSet3D(Var::atmosphere_dim(ws).value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), Var::verbosity(ws).value());

}


inline void AtmRawRead(

            Workspace& ws,

      const Var::String basename) {

  AtmRawRead(Var::t_field_raw(ws).value(), Var::z_field_raw(ws).value(), Var::vmr_field_raw(ws).value(), Var::nlte_field_raw(ws).value(), Var::nlte_level_identifiers(ws).value(), Var::nlte_vibrational_energies(ws).value(), Var::abs_species(ws).value(), basename.value(), Var::verbosity(ws).value());

}


inline void AtmWithNLTERawRead(

            Workspace& ws,

      const Var::String basename,

      const Var::Index expect_vibrational_energies=Group::Index{0}) {

  AtmWithNLTERawRead(Var::t_field_raw(ws).value(), Var::z_field_raw(ws).value(), Var::vmr_field_raw(ws).value(), Var::nlte_field_raw(ws).value(), Var::nlte_level_identifiers(ws).value(), Var::nlte_vibrational_energies(ws).value(), Var::abs_species(ws).value(), basename.value(), expect_vibrational_energies.value(), Var::verbosity(ws).value());

}


inline void atm_fields_compactAddConstant(

            Workspace& ws,

      const Var::String name,

      const Var::Numeric value,

      const Var::Index prepend=Group::Index{0},

      const Var::ArrayOfString condensibles=Group::ArrayOfString{}) {

  atm_fields_compactAddConstant(Var::atm_fields_compact(ws).value(), name.value(), value.value(), prepend.value(), condensibles.value(), Var::verbosity(ws).value());

}


inline void atm_fields_compactAddSpecies(

            Workspace& ws,

      const Var::String name,

      const Var::GriddedField3 value,

      const Var::Index prepend=Group::Index{0}) {

  atm_fields_compactAddSpecies(Var::atm_fields_compact(ws).value(), name.value(), value.value(), prepend.value(), Var::verbosity(ws).value());

}


inline void atm_fields_compactCleanup(

            Workspace& ws,

      const Var::Numeric threshold) {

  atm_fields_compactCleanup(Var::atm_fields_compact(ws).value(), threshold.value(), Var::verbosity(ws).value());

}


inline void atm_fields_compactCreateFromField(

            Workspace& ws,

      const Var::String name,

      const Var::GriddedField3 field) {

  atm_fields_compactCreateFromField(Var::atm_fields_compact(ws).value(), name.value(), field.value(), Var::verbosity(ws).value());

}


inline void atm_fields_compactFromMatrix(

            Workspace& ws,

      const Var::Matrix gin1,

      const Var::ArrayOfString field_names) {

  atm_fields_compactFromMatrix(Var::atm_fields_compact(ws).value(), Var::atmosphere_dim(ws).value(), gin1.value(), field_names.value(), Var::verbosity(ws).value());

}


inline void backend_channel_responseFlat(

            Workspace& ws,

      const Var::Numeric resolution) {

  backend_channel_responseFlat(Var::backend_channel_response(ws).value(), resolution.value(), Var::verbosity(ws).value());

}


inline void backend_channel_responseGaussian(

            Workspace& ws,

      const Var::Vector fwhm,

      const Var::Vector xwidth_si=Group::Vector{{3}},

      const Var::Vector dx_si=Group::Vector{{0.1}}) {

  backend_channel_responseGaussian(Var::backend_channel_response(ws).value(), fwhm.value(), xwidth_si.value(), dx_si.value(), Var::verbosity(ws).value());

}


inline void batch_atm_fields_compactAddConstant(

            Workspace& ws,

      const Var::String name,

      const Var::Numeric value,

      const Var::Index prepend=Group::Index{0},

      const Var::ArrayOfString condensibles=Group::ArrayOfString{}) {

  batch_atm_fields_compactAddConstant(Var::batch_atm_fields_compact(ws).value(), name.value(), value.value(), prepend.value(), condensibles.value(), Var::verbosity(ws).value());

}


inline void batch_atm_fields_compactAddSpecies(

            Workspace& ws,

      const Var::String name,

      const Var::GriddedField3 value,

      const Var::Index prepend=Group::Index{0}) {

  batch_atm_fields_compactAddSpecies(Var::batch_atm_fields_compact(ws).value(), name.value(), value.value(), prepend.value(), Var::verbosity(ws).value());

}


inline void batch_atm_fields_compactCleanup(

            Workspace& ws,

      const Var::Numeric threshold) {

  batch_atm_fields_compactCleanup(Var::batch_atm_fields_compact(ws).value(), threshold.value(), Var::verbosity(ws).value());

}


inline void batch_atm_fields_compactFromArrayOfMatrix(

            Workspace& ws,

      const Var::ArrayOfMatrix atmospheres_fields,

      const Var::ArrayOfString field_names) {

  batch_atm_fields_compactFromArrayOfMatrix(Var::batch_atm_fields_compact(ws).value(), Var::atmosphere_dim(ws).value(), atmospheres_fields.value(), field_names.value(), Var::verbosity(ws).value());

}


inline void CIAInfo(

            Workspace& ws,

      const Var::String catalogpath,

      const Var::ArrayOfString cia_tags) {

  CIAInfo(catalogpath.value(), cia_tags.value(), Var::verbosity(ws).value());

}


inline void CIARecordReadFromFile(

            Workspace& ws,

            Var::CIARecord cia_record,

      const Var::String species_tag,

      const Var::String filename) {

  if (cia_record.islast()) {

    throw std::runtime_error("cia_record needs to be a defined WorkspaceCIARecord since it is output of CIARecordReadFromFile");

  }


  CIARecordReadFromFile(cia_record.value(), species_tag.value(), filename.value(), Var::verbosity(ws).value());

}


inline void cloudboxOff(

            Workspace& ws) {

  cloudboxOff(Var::cloudbox_on(ws).value(), Var::ppath_inside_cloudbox_do(ws).value(), Var::cloudbox_limits(ws).value(), Var::iy_cloudbox_agenda(ws).value(), Var::pnd_field(ws).value(), Var::dpnd_field_dx(ws).value(), Var::scat_species(ws).value(), Var::scat_data(ws).value(), Var::scat_data_raw(ws).value(), Var::scat_data_checked(ws).value(), Var::particle_masses(ws).value(), Var::jacobian_quantities(ws).value(), Var::verbosity(ws).value());

}


inline void cloudboxSetAutomatically(

            Workspace& ws,

      const Var::Tensor4 particle_field,

      const Var::ArrayOfIndex cloudbox_limits_old=Group::ArrayOfIndex{{-1}},

      const Var::Numeric cloudbox_margin=Group::Numeric{-1}) {

  cloudboxSetAutomatically(Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), particle_field.value(), cloudbox_limits_old.value(), cloudbox_margin.value(), Var::verbosity(ws).value());

}


inline void cloudboxSetFullAtm(

            Workspace& ws) {

  cloudboxSetFullAtm(Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::verbosity(ws).value());

}


inline void cloudboxSetManually(

            Workspace& ws,

      const Var::Numeric p1,

      const Var::Numeric p2,

      const Var::Numeric lat1,

      const Var::Numeric lat2,

      const Var::Numeric lon1,

      const Var::Numeric lon2) {

  cloudboxSetManually(Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), p1.value(), p2.value(), lat1.value(), lat2.value(), lon1.value(), lon2.value(), Var::verbosity(ws).value());

}


inline void cloudboxSetManuallyAltitude(

            Workspace& ws,

      const Var::Numeric z1,

      const Var::Numeric z2,

      const Var::Numeric lat1,

      const Var::Numeric lat2,

      const Var::Numeric lon1,

      const Var::Numeric lon2) {

  cloudboxSetManuallyAltitude(Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::atmosphere_dim(ws).value(), Var::z_field(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), z1.value(), z2.value(), lat1.value(), lat2.value(), lon1.value(), lon2.value(), Var::verbosity(ws).value());

}


inline void cloudbox_checkedCalc(

            Workspace& ws,

      const Var::Index negative_pnd_ok=Group::Index{0}) {

  cloudbox_checkedCalc(Var::cloudbox_checked(ws).value(), Var::atmfields_checked(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::z_surface(ws).value(), Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::pnd_field(ws).value(), Var::dpnd_field_dx(ws).value(), Var::jacobian_quantities(ws).value(), Var::scat_data(ws).value(), Var::scat_species(ws).value(), Var::particle_masses(ws).value(), Var::abs_species(ws).value(), negative_pnd_ok.value(), Var::verbosity(ws).value());

}


inline void cloudbox_field_monoIterate(

            Workspace& ws,

      const Var::Index accelerated=Group::Index{0}) {

  cloudbox_field_monoIterate(ws, Var::cloudbox_field_mono(ws).value(), Var::doit_scat_field_agenda(ws).value(), Var::doit_rte_agenda(ws).value(), Var::doit_conv_test_agenda(ws).value(), accelerated.value(), Var::verbosity(ws).value());

}


inline void cloudbox_fieldCrop(

            Workspace& ws,

      const Var::Index new_limit0=Group::Index{0},

      const Var::Index new_limit1=Group::Index{0},

      const Var::Index new_limit2=Group::Index{0},

      const Var::Index new_limit3=Group::Index{0},

      const Var::Index new_limit4=Group::Index{0},

      const Var::Index new_limit5=Group::Index{0}) {

  cloudbox_fieldCrop(Var::cloudbox_field(ws).value(), Var::cloudbox_limits(ws).value(), Var::atmosphere_dim(ws).value(), Var::cloudbox_on(ws).value(), new_limit0.value(), new_limit1.value(), new_limit2.value(), new_limit3.value(), new_limit4.value(), new_limit5.value(), Var::verbosity(ws).value());

}


inline void cloudbox_fieldSetFromPrecalc(

            Workspace& ws,

      const Var::Tensor7 cloudbox_field_precalc) {

  cloudbox_fieldSetFromPrecalc(Var::cloudbox_field(ws).value(), Var::za_grid(ws).value(), Var::f_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::stokes_dim(ws).value(), Var::cloudbox_limits(ws).value(), Var::doit_is_initialized(ws).value(), cloudbox_field_precalc.value(), Var::verbosity(ws).value());

}


inline void cloudbox_fieldSetClearsky(

            Workspace& ws,

      const Var::Index all_frequencies=Group::Index{1}) {

  cloudbox_fieldSetClearsky(Var::cloudbox_field(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::cloudbox_limits(ws).value(), Var::atmosphere_dim(ws).value(), Var::cloudbox_on(ws).value(), Var::doit_is_initialized(ws).value(), all_frequencies.value(), Var::verbosity(ws).value());

}


inline void cloudbox_field_monoSetConst(

            Workspace& ws,

      const Var::Vector value) {

  cloudbox_field_monoSetConst(Var::cloudbox_field_mono(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::cloudbox_limits(ws).value(), Var::atmosphere_dim(ws).value(), Var::stokes_dim(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void cloudbox_fieldSetConst(

            Workspace& ws,

      const Var::Vector value) {

  cloudbox_fieldSetConst(Var::cloudbox_field(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::cloudbox_limits(ws).value(), Var::atmosphere_dim(ws).value(), Var::stokes_dim(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void cloudbox_fieldSetConstPerFreq(

            Workspace& ws,

      const Var::Matrix value) {

  cloudbox_fieldSetConstPerFreq(Var::cloudbox_field(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::cloudbox_limits(ws).value(), Var::atmosphere_dim(ws).value(), Var::stokes_dim(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void cloudbox_fieldUpdate1D(

            Workspace& ws) {

  cloudbox_fieldUpdate1D(ws, Var::cloudbox_field_mono(ws).value(), Var::doit_scat_field(ws).value(), Var::cloudbox_limits(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::vmr_field(ws).value(), Var::spt_calc_agenda(ws).value(), Var::za_grid(ws).value(), Var::pnd_field(ws).value(), Var::ppath_step_agenda(ws).value(), Var::ppath_lmax(ws).value(), Var::ppath_lraytrace(ws).value(), Var::p_grid(ws).value(), Var::z_field(ws).value(), Var::refellipsoid(ws).value(), Var::t_field(ws).value(), Var::f_grid(ws).value(), Var::f_index(ws).value(), Var::surface_rtprop_agenda(ws).value(), Var::doit_za_interp(ws).value(), Var::verbosity(ws).value());

}


inline void cloudbox_fieldUpdateSeq1D(

            Workspace& ws,

      const Var::Index normalize=Group::Index{1},

      const Var::Numeric norm_error_threshold=Group::Numeric{1.0},

      const Var::Index norm_debug=Group::Index{0}) {

  cloudbox_fieldUpdateSeq1D(ws, Var::cloudbox_field_mono(ws).value(), Var::doit_scat_field(ws).value(), Var::cloudbox_limits(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::vmr_field(ws).value(), Var::spt_calc_agenda(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::pnd_field(ws).value(), Var::ppath_step_agenda(ws).value(), Var::ppath_lmax(ws).value(), Var::ppath_lraytrace(ws).value(), Var::p_grid(ws).value(), Var::z_field(ws).value(), Var::refellipsoid(ws).value(), Var::t_field(ws).value(), Var::f_grid(ws).value(), Var::f_index(ws).value(), Var::surface_rtprop_agenda(ws).value(), Var::doit_za_interp(ws).value(), normalize.value(), norm_error_threshold.value(), norm_debug.value(), Var::verbosity(ws).value());

}


inline void cloudbox_fieldUpdateSeq1DPP(

            Workspace& ws) {

  cloudbox_fieldUpdateSeq1DPP(ws, Var::cloudbox_field_mono(ws).value(), Var::za_index(ws).value(), Var::doit_scat_field(ws).value(), Var::cloudbox_limits(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::vmr_field(ws).value(), Var::spt_calc_agenda(ws).value(), Var::za_grid(ws).value(), Var::pnd_field(ws).value(), Var::p_grid(ws).value(), Var::z_field(ws).value(), Var::t_field(ws).value(), Var::f_grid(ws).value(), Var::f_index(ws).value(), Var::verbosity(ws).value());

}


inline void cloudbox_fieldUpdateSeq3D(

            Workspace& ws) {

  cloudbox_fieldUpdateSeq3D(ws, Var::cloudbox_field_mono(ws).value(), Var::doit_scat_field(ws).value(), Var::cloudbox_limits(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::vmr_field(ws).value(), Var::spt_calc_agenda(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::pnd_field(ws).value(), Var::ppath_step_agenda(ws).value(), Var::ppath_lmax(ws).value(), Var::ppath_lraytrace(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::refellipsoid(ws).value(), Var::t_field(ws).value(), Var::f_grid(ws).value(), Var::f_index(ws).value(), Var::doit_za_interp(ws).value(), Var::verbosity(ws).value());

}


inline void cloudbox_field_monoOptimizeReverse(

            Workspace& ws) {

  cloudbox_field_monoOptimizeReverse(Var::cloudbox_field_mono(ws).value(), Var::p_grid_orig(ws).value(), Var::p_grid(ws).value(), Var::cloudbox_limits(ws).value(), Var::verbosity(ws).value());

}


inline void Compare(

            Workspace& ws,

      const Var::Numeric var1,

      const Var::Numeric var2,

      const Var::Numeric maxabsdiff=Group::Numeric{},

      const Var::String error_message=Group::String{""}) {

  Compare(var1.value(), var2.value(), maxabsdiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsdiff.islast() ? Group::String{"maxabsdiff"} : maxabsdiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void Compare(

            Workspace& ws,

      const Var::Vector var1,

      const Var::Vector var2,

      const Var::Numeric maxabsdiff=Group::Numeric{},

      const Var::String error_message=Group::String{""}) {

  Compare(var1.value(), var2.value(), maxabsdiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsdiff.islast() ? Group::String{"maxabsdiff"} : maxabsdiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void Compare(

            Workspace& ws,

      const Var::Matrix var1,

      const Var::Matrix var2,

      const Var::Numeric maxabsdiff=Group::Numeric{},

      const Var::String error_message=Group::String{""}) {

  Compare(var1.value(), var2.value(), maxabsdiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsdiff.islast() ? Group::String{"maxabsdiff"} : maxabsdiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void Compare(

            Workspace& ws,

      const Var::Tensor3 var1,

      const Var::Tensor3 var2,

      const Var::Numeric maxabsdiff=Group::Numeric{},

      const Var::String error_message=Group::String{""}) {

  Compare(var1.value(), var2.value(), maxabsdiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsdiff.islast() ? Group::String{"maxabsdiff"} : maxabsdiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void Compare(

            Workspace& ws,

      const Var::Tensor4 var1,

      const Var::Tensor4 var2,

      const Var::Numeric maxabsdiff=Group::Numeric{},

      const Var::String error_message=Group::String{""}) {

  Compare(var1.value(), var2.value(), maxabsdiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsdiff.islast() ? Group::String{"maxabsdiff"} : maxabsdiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void Compare(

            Workspace& ws,

      const Var::Tensor5 var1,

      const Var::Tensor5 var2,

      const Var::Numeric maxabsdiff=Group::Numeric{},

      const Var::String error_message=Group::String{""}) {

  Compare(var1.value(), var2.value(), maxabsdiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsdiff.islast() ? Group::String{"maxabsdiff"} : maxabsdiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void Compare(

            Workspace& ws,

      const Var::Tensor7 var1,

      const Var::Tensor7 var2,

      const Var::Numeric maxabsdiff=Group::Numeric{},

      const Var::String error_message=Group::String{""}) {

  Compare(var1.value(), var2.value(), maxabsdiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsdiff.islast() ? Group::String{"maxabsdiff"} : maxabsdiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void Compare(

            Workspace& ws,

      const Var::ArrayOfVector var1,

      const Var::ArrayOfVector var2,

      const Var::Numeric maxabsdiff=Group::Numeric{},

      const Var::String error_message=Group::String{""}) {

  Compare(var1.value(), var2.value(), maxabsdiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsdiff.islast() ? Group::String{"maxabsdiff"} : maxabsdiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void Compare(

            Workspace& ws,

      const Var::ArrayOfMatrix var1,

      const Var::ArrayOfMatrix var2,

      const Var::Numeric maxabsdiff=Group::Numeric{},

      const Var::String error_message=Group::String{""}) {

  Compare(var1.value(), var2.value(), maxabsdiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsdiff.islast() ? Group::String{"maxabsdiff"} : maxabsdiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void Compare(

            Workspace& ws,

      const Var::ArrayOfTensor7 var1,

      const Var::ArrayOfTensor7 var2,

      const Var::Numeric maxabsdiff=Group::Numeric{},

      const Var::String error_message=Group::String{""}) {

  Compare(var1.value(), var2.value(), maxabsdiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsdiff.islast() ? Group::String{"maxabsdiff"} : maxabsdiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void Compare(

            Workspace& ws,

      const Var::GriddedField3 var1,

      const Var::GriddedField3 var2,

      const Var::Numeric maxabsdiff=Group::Numeric{},

      const Var::String error_message=Group::String{""}) {

  Compare(var1.value(), var2.value(), maxabsdiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsdiff.islast() ? Group::String{"maxabsdiff"} : maxabsdiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void Compare(

            Workspace& ws,

      const Var::Sparse var1,

      const Var::Sparse var2,

      const Var::Numeric maxabsdiff=Group::Numeric{},

      const Var::String error_message=Group::String{""}) {

  Compare(var1.value(), var2.value(), maxabsdiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsdiff.islast() ? Group::String{"maxabsdiff"} : maxabsdiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void Compare(

            Workspace& ws,

      const Var::SingleScatteringData var1,

      const Var::SingleScatteringData var2,

      const Var::Numeric maxabsdiff=Group::Numeric{},

      const Var::String error_message=Group::String{""}) {

  Compare(var1.value(), var2.value(), maxabsdiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsdiff.islast() ? Group::String{"maxabsdiff"} : maxabsdiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::Numeric var1,

      const Var::Numeric var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::Vector var1,

      const Var::Vector var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::Matrix var1,

      const Var::Matrix var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::Tensor3 var1,

      const Var::Tensor3 var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::Tensor4 var1,

      const Var::Tensor4 var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::Tensor5 var1,

      const Var::Tensor5 var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::Tensor6 var1,

      const Var::Tensor6 var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::Tensor7 var1,

      const Var::Tensor7 var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::ArrayOfVector var1,

      const Var::ArrayOfVector var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::ArrayOfMatrix var1,

      const Var::ArrayOfMatrix var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::ArrayOfTensor3 var1,

      const Var::ArrayOfTensor3 var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::ArrayOfTensor4 var1,

      const Var::ArrayOfTensor4 var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::ArrayOfTensor6 var1,

      const Var::ArrayOfTensor6 var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::ArrayOfTensor7 var1,

      const Var::ArrayOfTensor7 var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::ArrayOfArrayOfVector var1,

      const Var::ArrayOfArrayOfVector var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::ArrayOfArrayOfMatrix var1,

      const Var::ArrayOfArrayOfMatrix var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor3 var1,

      const Var::ArrayOfArrayOfTensor3 var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor6 var1,

      const Var::ArrayOfArrayOfTensor6 var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::ArrayOfPropagationMatrix var1,

      const Var::ArrayOfPropagationMatrix var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::ArrayOfArrayOfPropagationMatrix var1,

      const Var::ArrayOfArrayOfPropagationMatrix var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::ArrayOfStokesVector var1,

      const Var::ArrayOfStokesVector var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::ArrayOfArrayOfStokesVector var1,

      const Var::ArrayOfArrayOfStokesVector var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void CompareRelative(

            Workspace& ws,

      const Var::EnergyLevelMap var1,

      const Var::EnergyLevelMap var2,

      const Var::Numeric maxabsreldiff,

      const Var::String error_message=Group::String{""}) {

  CompareRelative(var1.value(), var2.value(), maxabsreldiff.value(), error_message.value(), var1.islast() ? Group::String{"var1"} : var1.name(), var2.islast() ? Group::String{"var2"} : var2.name(), maxabsreldiff.islast() ? Group::String{"maxabsreldiff"} : maxabsreldiff.name(), error_message.islast() ? Group::String{"error_message"} : error_message.name(), Var::verbosity(ws).value());

}


inline void complex_refr_indexConstant(

            Workspace& ws,

      const Var::Numeric refr_index_real,

      const Var::Numeric refr_index_imag) {

  complex_refr_indexConstant(Var::complex_refr_index(ws).value(), refr_index_real.value(), refr_index_imag.value(), Var::verbosity(ws).value());

}


inline void complex_refr_indexIceMatzler06(

            Workspace& ws,

      const Var::Vector data_f_grid,

      const Var::Vector data_T_grid) {

  complex_refr_indexIceMatzler06(Var::complex_refr_index(ws).value(), data_f_grid.value(), data_T_grid.value(), Var::verbosity(ws).value());

}


inline void complex_refr_indexIceWarren84(

            Workspace& ws,

      const Var::Vector data_f_grid,

      const Var::Vector data_T_grid) {

  complex_refr_indexIceWarren84(Var::complex_refr_index(ws).value(), data_f_grid.value(), data_T_grid.value(), Var::verbosity(ws).value());

}


inline void complex_refr_indexWaterLiebe93(

            Workspace& ws,

      const Var::Vector data_f_grid,

      const Var::Vector data_T_grid) {

  complex_refr_indexWaterLiebe93(Var::complex_refr_index(ws).value(), data_f_grid.value(), data_T_grid.value(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::AbsorptionLines out,

      const Var::AbsorptionLines in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceAbsorptionLines since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Agenda out,

      const Var::Agenda in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceAgenda since it is output of Copy");

  }


  Copy(ws, out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfAbsorptionLines out,

      const Var::ArrayOfAbsorptionLines in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAbsorptionLines since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfAbsorptionLines out,

      const Var::ArrayOfArrayOfAbsorptionLines in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfAgenda out,

      const Var::ArrayOfAgenda in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAgenda since it is output of Copy");

  }


  Copy(ws, out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField1 out,

      const Var::ArrayOfArrayOfGriddedField1 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField2 out,

      const Var::ArrayOfArrayOfGriddedField2 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField3 out,

      const Var::ArrayOfArrayOfGriddedField3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfIndex out,

      const Var::ArrayOfArrayOfIndex in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfIndex since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfMatrix out,

      const Var::ArrayOfArrayOfMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfPpath out,

      const Var::ArrayOfPpath in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPpath since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfPropagationMatrix out,

      const Var::ArrayOfArrayOfPropagationMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfRadiationVector out,

      const Var::ArrayOfArrayOfRadiationVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfScatteringMetaData out,

      const Var::ArrayOfArrayOfScatteringMetaData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfSingleScatteringData out,

      const Var::ArrayOfArrayOfSingleScatteringData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfSpeciesTag out,

      const Var::ArrayOfArrayOfSpeciesTag in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfStokesVector out,

      const Var::ArrayOfArrayOfStokesVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfString out,

      const Var::ArrayOfArrayOfString in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfString since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfTensor3 out,

      const Var::ArrayOfArrayOfTensor3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfTensor6 out,

      const Var::ArrayOfArrayOfTensor6 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfTime out,

      const Var::ArrayOfArrayOfTime in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTime since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfTransmissionMatrix out,

      const Var::ArrayOfArrayOfTransmissionMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfArrayOfVector out,

      const Var::ArrayOfArrayOfVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfVector since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfCIARecord out,

      const Var::ArrayOfCIARecord in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfCIARecord since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfGriddedField1 out,

      const Var::ArrayOfGriddedField1 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField1 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfGriddedField2 out,

      const Var::ArrayOfGriddedField2 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField2 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfGriddedField3 out,

      const Var::ArrayOfGriddedField3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfGriddedField4 out,

      const Var::ArrayOfGriddedField4 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField4 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfIndex out,

      const Var::ArrayOfIndex in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfMatrix out,

      const Var::ArrayOfMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfMatrix since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfPropagationMatrix out,

      const Var::ArrayOfPropagationMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPropagationMatrix since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfQuantumIdentifier out,

      const Var::ArrayOfQuantumIdentifier in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfRadiationVector out,

      const Var::ArrayOfRadiationVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRadiationVector since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfRetrievalQuantity out,

      const Var::ArrayOfRetrievalQuantity in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfScatteringMetaData out,

      const Var::ArrayOfScatteringMetaData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfScatteringMetaData since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfSingleScatteringData out,

      const Var::ArrayOfSingleScatteringData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfSparse out,

      const Var::ArrayOfSparse in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSparse since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfStokesVector out,

      const Var::ArrayOfStokesVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfStokesVector since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfString out,

      const Var::ArrayOfString in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfString since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfTelsemAtlas out,

      const Var::ArrayOfTelsemAtlas in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTelsemAtlas since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfTensor3 out,

      const Var::ArrayOfTensor3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor3 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfTensor4 out,

      const Var::ArrayOfTensor4 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor4 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfTensor5 out,

      const Var::ArrayOfTensor5 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor5 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfTensor6 out,

      const Var::ArrayOfTensor6 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor6 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfTensor7 out,

      const Var::ArrayOfTensor7 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor7 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfTime out,

      const Var::ArrayOfTime in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTime since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfTransmissionMatrix out,

      const Var::ArrayOfTransmissionMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfVector out,

      const Var::ArrayOfVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ArrayOfXsecRecord out,

      const Var::ArrayOfXsecRecord in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfXsecRecord since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::CIARecord out,

      const Var::CIARecord in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceCIARecord since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::CovarianceMatrix out,

      const Var::CovarianceMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceCovarianceMatrix since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::EnergyLevelMap out,

      const Var::EnergyLevelMap in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceEnergyLevelMap since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::GasAbsLookup out,

      const Var::GasAbsLookup in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGasAbsLookup since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::GridPos out,

      const Var::GridPos in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGridPos since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::GriddedField1 out,

      const Var::GriddedField1 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField1 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::GriddedField2 out,

      const Var::GriddedField2 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField2 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::GriddedField3 out,

      const Var::GriddedField3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField3 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::GriddedField4 out,

      const Var::GriddedField4 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField4 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::GriddedField5 out,

      const Var::GriddedField5 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField5 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::GriddedField6 out,

      const Var::GriddedField6 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField6 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::HitranRelaxationMatrixData out,

      const Var::HitranRelaxationMatrixData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceHitranRelaxationMatrixData since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Index out,

      const Var::Index in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::MCAntenna out,

      const Var::MCAntenna in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMCAntenna since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Matrix out,

      const Var::Matrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Numeric out,

      const Var::Numeric in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Ppath out,

      const Var::Ppath in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspacePpath since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::PropagationMatrix out,

      const Var::PropagationMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspacePropagationMatrix since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::QuantumIdentifier out,

      const Var::QuantumIdentifier in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceQuantumIdentifier since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::RadiationVector out,

      const Var::RadiationVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRadiationVector since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Rational out,

      const Var::Rational in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRational since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::ScatteringMetaData out,

      const Var::ScatteringMetaData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceScatteringMetaData since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::SingleScatteringData out,

      const Var::SingleScatteringData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSingleScatteringData since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Sparse out,

      const Var::Sparse in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::SpeciesAuxData out,

      const Var::SpeciesAuxData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSpeciesAuxData since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::StokesVector out,

      const Var::StokesVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceStokesVector since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::String out,

      const Var::String in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceString since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::TelsemAtlas out,

      const Var::TelsemAtlas in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTelsemAtlas since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Tensor3 out,

      const Var::Tensor3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Tensor4 out,

      const Var::Tensor4 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Tensor5 out,

      const Var::Tensor5 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor5 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Tensor6 out,

      const Var::Tensor6 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor6 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Tensor7 out,

      const Var::Tensor7 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor7 since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Timer out,

      const Var::Timer in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTimer since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Time out,

      const Var::Time in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTime since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::TessemNN out,

      const Var::TessemNN in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTessemNN since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::TransmissionMatrix out,

      const Var::TransmissionMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTransmissionMatrix since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Vector out,

      const Var::Vector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void Copy(

            Workspace& ws,

            Var::Verbosity out,

      const Var::Verbosity in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVerbosity since it is output of Copy");

  }


  Copy(out.value(), out.name(), in.value(), in.islast() ? Group::String{"in"} : in.name(), Var::verbosity(ws).value());

}


inline void covmat1D(

            Workspace& ws,

            Var::Matrix out,

      const Var::Vector grid_1,

      const Var::Vector sigma_1,

      const Var::Vector cls_1,

      const Var::String fname,

      const Var::Vector grid_2=Group::Vector{},

      const Var::Vector sigma_2=Group::Vector{},

      const Var::Vector cls_2=Group::Vector{},

      const Var::Numeric co=Group::Numeric{0.0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of covmat1D");

  }


  covmat1D(out.value(), grid_1.value(), grid_2.value(), sigma_1.value(), sigma_2.value(), cls_1.value(), cls_2.value(), co.value(), fname.value(), Var::verbosity(ws).value());

}


inline void covmat1D(

            Workspace& ws,

            Var::Sparse out,

      const Var::Vector grid_1,

      const Var::Vector sigma_1,

      const Var::Vector cls_1,

      const Var::String fname,

      const Var::Vector grid_2=Group::Vector{},

      const Var::Vector sigma_2=Group::Vector{},

      const Var::Vector cls_2=Group::Vector{},

      const Var::Numeric co=Group::Numeric{0.0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of covmat1D");

  }


  covmat1D(out.value(), grid_1.value(), grid_2.value(), sigma_1.value(), sigma_2.value(), cls_1.value(), cls_2.value(), co.value(), fname.value(), Var::verbosity(ws).value());

}


inline void covmat1DMarkov(

            Workspace& ws,

            Var::Matrix out,

            Var::Matrix out_inverse,

      const Var::Vector grid,

      const Var::Vector sigma,

      const Var::Numeric lc,

      const Var::Numeric co=Group::Numeric{0.0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of covmat1DMarkov");

  } if (out_inverse.islast()) {

    throw std::runtime_error("out_inverse needs to be a defined WorkspaceMatrix since it is output of covmat1DMarkov");

  }


  covmat1DMarkov(out.value(), out_inverse.value(), grid.value(), sigma.value(), lc.value(), co.value(), Var::verbosity(ws).value());

}


inline void covmat1DMarkov(

            Workspace& ws,

            Var::Sparse out,

            Var::Sparse out_inverse,

      const Var::Vector grid,

      const Var::Vector sigma,

      const Var::Numeric lc,

      const Var::Numeric co=Group::Numeric{0.0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of covmat1DMarkov");

  } if (out_inverse.islast()) {

    throw std::runtime_error("out_inverse needs to be a defined WorkspaceSparse since it is output of covmat1DMarkov");

  }


  covmat1DMarkov(out.value(), out_inverse.value(), grid.value(), sigma.value(), lc.value(), co.value(), Var::verbosity(ws).value());

}


inline void covmatDiagonal(

            Workspace& ws,

            Var::Matrix out,

            Var::Matrix out_inverse,

      const Var::Vector vars) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of covmatDiagonal");

  } if (out_inverse.islast()) {

    throw std::runtime_error("out_inverse needs to be a defined WorkspaceMatrix since it is output of covmatDiagonal");

  }


  covmatDiagonal(out.value(), out_inverse.value(), vars.value(), Var::verbosity(ws).value());

}


inline void covmatDiagonal(

            Workspace& ws,

            Var::Sparse out,

            Var::Sparse out_inverse,

      const Var::Vector vars) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of covmatDiagonal");

  } if (out_inverse.islast()) {

    throw std::runtime_error("out_inverse needs to be a defined WorkspaceSparse since it is output of covmatDiagonal");

  }


  covmatDiagonal(out.value(), out_inverse.value(), vars.value(), Var::verbosity(ws).value());

}


inline void covmat_seAddBlock(

            Workspace& ws,

      const Var::Matrix block,

      const Var::Index i=Group::Index{-1},

      const Var::Index j=Group::Index{-1}) {

  covmat_seAddBlock(Var::covmat_se(ws).value(), block.value(), i.value(), j.value(), Var::verbosity(ws).value());

}


inline void covmat_seAddBlock(

            Workspace& ws,

      const Var::Sparse block,

      const Var::Index i=Group::Index{-1},

      const Var::Index j=Group::Index{-1}) {

  covmat_seAddBlock(Var::covmat_se(ws).value(), block.value(), i.value(), j.value(), Var::verbosity(ws).value());

}


inline void covmat_seAddInverseBlock(

            Workspace& ws,

      const Var::Matrix block,

      const Var::Index i=Group::Index{-1},

      const Var::Index j=Group::Index{-1}) {

  covmat_seAddInverseBlock(Var::covmat_se(ws).value(), block.value(), i.value(), j.value(), Var::verbosity(ws).value());

}


inline void covmat_seAddInverseBlock(

            Workspace& ws,

      const Var::Sparse block,

      const Var::Index i=Group::Index{-1},

      const Var::Index j=Group::Index{-1}) {

  covmat_seAddInverseBlock(Var::covmat_se(ws).value(), block.value(), i.value(), j.value(), Var::verbosity(ws).value());

}


inline void covmat_seSet(

            Workspace& ws,

      const Var::CovarianceMatrix covmat) {

  covmat_seSet(Var::covmat_se(ws).value(), covmat.value(), Var::verbosity(ws).value());

}


inline void covmat_seSet(

            Workspace& ws,

      const Var::Matrix covmat) {

  covmat_seSet(Var::covmat_se(ws).value(), covmat.value(), Var::verbosity(ws).value());

}


inline void covmat_seSet(

            Workspace& ws,

      const Var::Sparse covmat) {

  covmat_seSet(Var::covmat_se(ws).value(), covmat.value(), Var::verbosity(ws).value());

}


inline void covmat_sxSet(

            Workspace& ws,

      const Var::CovarianceMatrix covmat) {

  covmat_sxSet(Var::covmat_sx(ws).value(), covmat.value(), Var::verbosity(ws).value());

}


inline void covmat_sxSet(

            Workspace& ws,

      const Var::Matrix covmat) {

  covmat_sxSet(Var::covmat_sx(ws).value(), covmat.value(), Var::verbosity(ws).value());

}


inline void covmat_sxSet(

            Workspace& ws,

      const Var::Sparse covmat) {

  covmat_sxSet(Var::covmat_sx(ws).value(), covmat.value(), Var::verbosity(ws).value());

}


inline void covmat_sxAddBlock(

            Workspace& ws,

      const Var::Matrix block,

      const Var::Index i=Group::Index{-1},

      const Var::Index j=Group::Index{-1}) {

  covmat_sxAddBlock(Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), block.value(), i.value(), j.value(), Var::verbosity(ws).value());

}


inline void covmat_sxAddBlock(

            Workspace& ws,

      const Var::Sparse block,

      const Var::Index i=Group::Index{-1},

      const Var::Index j=Group::Index{-1}) {

  covmat_sxAddBlock(Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), block.value(), i.value(), j.value(), Var::verbosity(ws).value());

}


inline void covmat_sxAddInverseBlock(

            Workspace& ws,

      const Var::Matrix block,

      const Var::Index i=Group::Index{-1},

      const Var::Index j=Group::Index{-1}) {

  covmat_sxAddInverseBlock(Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), block.value(), i.value(), j.value(), Var::verbosity(ws).value());

}


inline void covmat_sxAddInverseBlock(

            Workspace& ws,

      const Var::Sparse block,

      const Var::Index i=Group::Index{-1},

      const Var::Index j=Group::Index{-1}) {

  covmat_sxAddInverseBlock(Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), block.value(), i.value(), j.value(), Var::verbosity(ws).value());

}


inline void covmat_sxExtractSqrtDiagonal(

            Workspace& ws,

            Var::Vector x_norm) {

  if (x_norm.islast()) {

    throw std::runtime_error("x_norm needs to be a defined WorkspaceVector since it is output of covmat_sxExtractSqrtDiagonal");

  }


  covmat_sxExtractSqrtDiagonal(x_norm.value(), Var::covmat_sx(ws).value(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::AbsorptionLines v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Agenda v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfAbsorptionLines v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfAbsorptionLines v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfAgenda v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField1 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField2 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField3 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfIndex v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfMatrix v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfPpath v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfPropagationMatrix v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfRadiationVector v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfScatteringMetaData v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfSingleScatteringData v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfSpeciesTag v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfStokesVector v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfString v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor3 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor6 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfTime v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfTransmissionMatrix v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfArrayOfVector v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfCIARecord v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfGriddedField1 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfGriddedField2 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfGriddedField3 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfGriddedField4 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfIndex v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfMatrix v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfPropagationMatrix v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfRadiationVector v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfRetrievalQuantity v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfScatteringMetaData v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfSingleScatteringData v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfSparse v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfStokesVector v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfString v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfTelsemAtlas v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfTensor3 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfTensor4 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfTensor5 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfTensor6 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfTensor7 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfTime v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfTransmissionMatrix v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfVector v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ArrayOfXsecRecord v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::CIARecord v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::CovarianceMatrix v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::EnergyLevelMap v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::GasAbsLookup v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::GridPos v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::GriddedField1 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::GriddedField2 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::GriddedField3 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::GriddedField4 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::GriddedField5 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::GriddedField6 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::HitranRelaxationMatrixData v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Index v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::MCAntenna v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Matrix v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Numeric v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Ppath v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::PropagationMatrix v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::QuantumIdentifier v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::RadiationVector v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Rational v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::ScatteringMetaData v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::SingleScatteringData v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Sparse v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::SpeciesAuxData v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::StokesVector v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::String v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::TelsemAtlas v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Tensor3 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Tensor4 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Tensor5 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Tensor6 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Tensor7 v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Timer v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Time v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::TessemNN v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::TransmissionMatrix v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Vector v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void Delete(

            Workspace& ws,

      const Var::Verbosity v) {

  Delete(ws, v.value(), v.islast() ? Group::String{"v"} : v.name(), Var::verbosity(ws).value());

}


inline void diameter_maxFromDiameter_volume_equ(

            Workspace& ws,

            Var::Numeric diameter_max,

            Var::Numeric diameter_area_equ,

      const Var::String shape,

      const Var::Numeric diameter_volume_equ,

      const Var::Numeric aspect_ratio) {

  if (diameter_max.islast()) {

    throw std::runtime_error("diameter_max needs to be a defined WorkspaceNumeric since it is output of diameter_maxFromDiameter_volume_equ");

  } if (diameter_area_equ.islast()) {

    throw std::runtime_error("diameter_area_equ needs to be a defined WorkspaceNumeric since it is output of diameter_maxFromDiameter_volume_equ");

  }


  diameter_maxFromDiameter_volume_equ(diameter_max.value(), diameter_area_equ.value(), shape.value(), diameter_volume_equ.value(), aspect_ratio.value(), Var::verbosity(ws).value());

}


inline void diameter_volume_equFromDiameter_max(

            Workspace& ws,

            Var::Numeric diameter_volume_equ,

            Var::Numeric volume,

      const Var::String shape,

      const Var::Numeric diameter_max,

      const Var::Numeric aspect_ratio) {

  if (diameter_volume_equ.islast()) {

    throw std::runtime_error("diameter_volume_equ needs to be a defined WorkspaceNumeric since it is output of diameter_volume_equFromDiameter_max");

  } if (volume.islast()) {

    throw std::runtime_error("volume needs to be a defined WorkspaceNumeric since it is output of diameter_volume_equFromDiameter_max");

  }


  diameter_volume_equFromDiameter_max(diameter_volume_equ.value(), volume.value(), shape.value(), diameter_max.value(), aspect_ratio.value(), Var::verbosity(ws).value());

}


inline void DiagonalMatrix(

            Workspace& ws,

            Var::Matrix out,

      const Var::Vector v) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of DiagonalMatrix");

  }


  DiagonalMatrix(out.value(), v.value(), Var::verbosity(ws).value());

}


inline void DiagonalMatrix(

            Workspace& ws,

            Var::Sparse out,

      const Var::Vector v) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of DiagonalMatrix");

  }


  DiagonalMatrix(out.value(), v.value(), Var::verbosity(ws).value());

}


inline void DiffZaAa(

            Workspace& ws,

            Var::Matrix dlos,

      const Var::Vector ref_los,

      const Var::Matrix other_los) {

  if (dlos.islast()) {

    throw std::runtime_error("dlos needs to be a defined WorkspaceMatrix since it is output of DiffZaAa");

  }


  DiffZaAa(dlos.value(), ref_los.value(), other_los.value(), Var::verbosity(ws).value());

}


inline void DisortCalc(

            Workspace& ws,

      const Var::Index nstreams=Group::Index{8},

      const Var::String pfct_method=Group::String{"median"},

      const Var::Index Npfct=Group::Index{181},

      const Var::Index quiet=Group::Index{0}) {

  DisortCalc(ws, Var::cloudbox_field(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::scat_data_checked(ws).value(), Var::cloudbox_checked(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::pnd_field(ws).value(), Var::t_field(ws).value(), Var::z_field(ws).value(), Var::vmr_field(ws).value(), Var::p_grid(ws).value(), Var::scat_data(ws).value(), Var::f_grid(ws).value(), Var::za_grid(ws).value(), Var::stokes_dim(ws).value(), Var::z_surface(ws).value(), Var::surface_skin_t(ws).value(), Var::surface_scalar_reflectivity(ws).value(), nstreams.value(), pfct_method.value(), Npfct.value(), quiet.value(), Var::verbosity(ws).value());

}


inline void DisortCalcWithARTSSurface(

            Workspace& ws,

      const Var::Index nstreams=Group::Index{8},

      const Var::String pfct_method=Group::String{"median"},

      const Var::Index Npfct=Group::Index{181},

      const Var::Index quiet=Group::Index{0}) {

  DisortCalcWithARTSSurface(ws, Var::cloudbox_field(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::scat_data_checked(ws).value(), Var::cloudbox_checked(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::surface_rtprop_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::pnd_field(ws).value(), Var::t_field(ws).value(), Var::z_field(ws).value(), Var::vmr_field(ws).value(), Var::p_grid(ws).value(), Var::scat_data(ws).value(), Var::f_grid(ws).value(), Var::za_grid(ws).value(), Var::stokes_dim(ws).value(), nstreams.value(), pfct_method.value(), Npfct.value(), quiet.value(), Var::verbosity(ws).value());

}


inline void DisortCalcClearsky(

            Workspace& ws,

      const Var::Index nstreams=Group::Index{8},

      const Var::Index quiet=Group::Index{0}) {

  DisortCalcClearsky(ws, Var::spectral_radiance_field(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::t_field(ws).value(), Var::z_field(ws).value(), Var::vmr_field(ws).value(), Var::p_grid(ws).value(), Var::f_grid(ws).value(), Var::za_grid(ws).value(), Var::stokes_dim(ws).value(), Var::z_surface(ws).value(), Var::surface_skin_t(ws).value(), Var::surface_scalar_reflectivity(ws).value(), nstreams.value(), quiet.value(), Var::verbosity(ws).value());

}


inline void DOBatchCalc(

            Workspace& ws,

      const Var::Index robust=Group::Index{0}) {

  DOBatchCalc(ws, Var::dobatch_cloudbox_field(ws).value(), Var::dobatch_radiance_field(ws).value(), Var::dobatch_irradiance_field(ws).value(), Var::dobatch_spectral_irradiance_field(ws).value(), Var::ybatch_start(ws).value(), Var::ybatch_n(ws).value(), Var::dobatch_calc_agenda(ws).value(), robust.value(), Var::verbosity(ws).value());

}


inline void DOAngularGridsSet(

            Workspace& ws,

      const Var::Index N_za_grid,

      const Var::Index N_aa_grid=Group::Index{1},

      const Var::String za_grid_opt_file=Group::String{""}) {

  DOAngularGridsSet(Var::doit_za_grid_size(ws).value(), Var::aa_grid(ws).value(), Var::za_grid(ws).value(), N_za_grid.value(), N_aa_grid.value(), za_grid_opt_file.value(), Var::verbosity(ws).value());

}


inline void DoitCalc(

            Workspace& ws) {

  DoitCalc(ws, Var::cloudbox_field(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::cloudbox_checked(ws).value(), Var::scat_data_checked(ws).value(), Var::cloudbox_on(ws).value(), Var::f_grid(ws).value(), Var::doit_mono_agenda(ws).value(), Var::doit_is_initialized(ws).value(), Var::verbosity(ws).value());

}


inline void DoitGetIncoming(

            Workspace& ws,

      const Var::Index rigorous=Group::Index{1},

      const Var::Numeric maxratio=Group::Numeric{100}) {

  DoitGetIncoming(ws, Var::cloudbox_field(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::cloudbox_checked(ws).value(), Var::doit_is_initialized(ws).value(), Var::iy_main_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::nlte_field(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::f_grid(ws).value(), Var::stokes_dim(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), rigorous.value(), maxratio.value(), Var::verbosity(ws).value());

}


inline void DoitGetIncoming1DAtm(

            Workspace& ws) {

  DoitGetIncoming1DAtm(ws, Var::cloudbox_field(ws).value(), Var::cloudbox_on(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::cloudbox_checked(ws).value(), Var::doit_is_initialized(ws).value(), Var::iy_main_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::nlte_field(ws).value(), Var::cloudbox_limits(ws).value(), Var::f_grid(ws).value(), Var::stokes_dim(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::verbosity(ws).value());

}


inline void DoitInit(

            Workspace& ws) {

  DoitInit(Var::doit_scat_field(ws).value(), Var::cloudbox_field(ws).value(), Var::doit_is_initialized(ws).value(), Var::stokes_dim(ws).value(), Var::atmosphere_dim(ws).value(), Var::f_grid(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::doit_za_grid_size(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::verbosity(ws).value());

}


inline void DoitScatteringDataPrepare(

            Workspace& ws) {

  DoitScatteringDataPrepare(ws, Var::pha_mat_sptDOITOpt(ws).value(), Var::scat_data_mono(ws).value(), Var::pha_mat_doit(ws).value(), Var::aa_grid(ws).value(), Var::doit_za_grid_size(ws).value(), Var::scat_data(ws).value(), Var::scat_data_checked(ws).value(), Var::f_index(ws).value(), Var::atmosphere_dim(ws).value(), Var::stokes_dim(ws).value(), Var::t_field(ws).value(), Var::cloudbox_limits(ws).value(), Var::pnd_field(ws).value(), Var::pha_mat_spt_agenda(ws).value(), Var::verbosity(ws).value());

}


inline void DoitWriteIterationFields(

            Workspace& ws,

      const Var::ArrayOfIndex iterations=Group::ArrayOfIndex{{-1}},

      const Var::ArrayOfIndex frequencies=Group::ArrayOfIndex{{-1}}) {

  DoitWriteIterationFields(Var::doit_iteration_counter(ws).value(), Var::cloudbox_field_mono(ws).value(), Var::f_index(ws).value(), iterations.value(), frequencies.value(), Var::verbosity(ws).value());

}


inline void doit_conv_flagAbs(

            Workspace& ws,

      const Var::Vector epsilon,

      const Var::Index max_iterations=Group::Index{100},

      const Var::Index nonconv_return_nan=Group::Index{0}) {

  doit_conv_flagAbs(Var::doit_conv_flag(ws).value(), Var::doit_iteration_counter(ws).value(), Var::cloudbox_field_mono(ws).value(), Var::cloudbox_field_mono_old(ws).value(), epsilon.value(), max_iterations.value(), nonconv_return_nan.value(), Var::verbosity(ws).value());

}


inline void doit_conv_flagAbsBT(

            Workspace& ws,

      const Var::Vector epsilon,

      const Var::Index max_iterations=Group::Index{100},

      const Var::Index nonconv_return_nan=Group::Index{0}) {

  doit_conv_flagAbsBT(Var::doit_conv_flag(ws).value(), Var::doit_iteration_counter(ws).value(), Var::cloudbox_field_mono(ws).value(), Var::cloudbox_field_mono_old(ws).value(), Var::f_grid(ws).value(), Var::f_index(ws).value(), epsilon.value(), max_iterations.value(), nonconv_return_nan.value(), Var::verbosity(ws).value());

}


inline void doit_conv_flagLsq(

            Workspace& ws,

      const Var::Vector epsilon,

      const Var::Index max_iterations=Group::Index{100},

      const Var::Index nonconv_return_nan=Group::Index{0}) {

  doit_conv_flagLsq(Var::doit_conv_flag(ws).value(), Var::doit_iteration_counter(ws).value(), Var::cloudbox_field_mono(ws).value(), Var::cloudbox_field_mono_old(ws).value(), Var::f_grid(ws).value(), Var::f_index(ws).value(), epsilon.value(), max_iterations.value(), nonconv_return_nan.value(), Var::verbosity(ws).value());

}


inline void OptimizeDoitPressureGrid(

            Workspace& ws,

      const Var::Numeric tau_scat_max=Group::Numeric{0.1},

      const Var::Numeric sgl_alb_max=Group::Numeric{0.9},

      const Var::Index cloudbox_size_max=Group::Index{200}) {

  OptimizeDoitPressureGrid(ws, Var::p_grid(ws).value(), Var::pnd_field(ws).value(), Var::t_field(ws).value(), Var::scat_data_mono(ws).value(), Var::z_field(ws).value(), Var::cloudbox_limits(ws).value(), Var::cloudbox_field_mono(ws).value(), Var::pha_mat_doit(ws).value(), Var::vmr_field(ws).value(), Var::p_grid_orig(ws).value(), Var::f_grid(ws).value(), Var::f_index(ws).value(), Var::propmat_clearsky_agenda(ws).value(), tau_scat_max.value(), sgl_alb_max.value(), cloudbox_size_max.value(), Var::verbosity(ws).value());

}


inline void doit_scat_fieldCalc(

            Workspace& ws) {

  doit_scat_fieldCalc(ws, Var::doit_scat_field(ws).value(), Var::pha_mat_spt_agenda(ws).value(), Var::cloudbox_field_mono(ws).value(), Var::pnd_field(ws).value(), Var::t_field(ws).value(), Var::atmosphere_dim(ws).value(), Var::cloudbox_limits(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::doit_za_grid_size(ws).value(), Var::pha_mat_doit(ws).value(), Var::verbosity(ws).value());

}


inline void doit_scat_fieldCalcLimb(

            Workspace& ws) {

  doit_scat_fieldCalcLimb(ws, Var::doit_scat_field(ws).value(), Var::pha_mat_spt_agenda(ws).value(), Var::cloudbox_field_mono(ws).value(), Var::pnd_field(ws).value(), Var::t_field(ws).value(), Var::atmosphere_dim(ws).value(), Var::cloudbox_limits(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::doit_za_grid_size(ws).value(), Var::doit_za_interp(ws).value(), Var::pha_mat_doit(ws).value(), Var::verbosity(ws).value());

}


inline void doit_za_grid_optCalc(

            Workspace& ws,

      const Var::Numeric acc) {

  doit_za_grid_optCalc(Var::doit_za_grid_opt(ws).value(), Var::cloudbox_field_mono(ws).value(), Var::za_grid(ws).value(), Var::doit_za_interp(ws).value(), acc.value(), Var::verbosity(ws).value());

}


inline void doit_za_interpSet(

            Workspace& ws,

      const Var::String interp_method=Group::String{"linear"}) {

  doit_za_interpSet(Var::doit_za_interp(ws).value(), Var::atmosphere_dim(ws).value(), interp_method.value(), Var::verbosity(ws).value());

}


inline void Duration(

            Workspace& ws,

            Var::Numeric duration,

      const Var::Time start,

      const Var::Time end) {

  if (duration.islast()) {

    throw std::runtime_error("duration needs to be a defined WorkspaceNumeric since it is output of Duration");

  }


  Duration(duration.value(), start.value(), end.value(), Var::verbosity(ws).value());

}


inline void EnergyLevelMapSet(

            Workspace& ws,

            Var::EnergyLevelMap x,

      const Var::EnergyLevelMap y) {

  if (x.islast()) {

    throw std::runtime_error("x needs to be a defined WorkspaceEnergyLevelMap since it is output of EnergyLevelMapSet");

  }


  EnergyLevelMapSet(x.value(), y.value(), Var::verbosity(ws).value());

}


inline void Error(

            Workspace& ws,

      const Var::String msg) {

  Error(msg.value(), Var::verbosity(ws).value());

}


inline void Exit(

            Workspace& ws) {

  Exit(Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::Index needle,

      const Var::ArrayOfIndex haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceIndex since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::ArrayOfIndex needle,

      const Var::ArrayOfArrayOfIndex haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceArrayOfIndex since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::Numeric needle,

      const Var::Vector haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceNumeric since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::Vector needle,

      const Var::ArrayOfVector haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceVector since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::Matrix needle,

      const Var::ArrayOfMatrix haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceMatrix since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::Matrix needle,

      const Var::Tensor3 haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceMatrix since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::Tensor3 needle,

      const Var::Tensor4 haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceTensor3 since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::Tensor4 needle,

      const Var::ArrayOfTensor4 haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceTensor4 since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::Tensor4 needle,

      const Var::Tensor5 haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceTensor4 since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::GriddedField3 needle,

      const Var::ArrayOfGriddedField3 haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceGriddedField3 since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::ArrayOfGriddedField3 needle,

      const Var::ArrayOfArrayOfGriddedField3 haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::GriddedField4 needle,

      const Var::ArrayOfGriddedField4 haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceGriddedField4 since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::String needle,

      const Var::ArrayOfString haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceString since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::SingleScatteringData needle,

      const Var::ArrayOfSingleScatteringData haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceSingleScatteringData since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::ArrayOfSingleScatteringData needle,

      const Var::ArrayOfArrayOfSingleScatteringData haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::TelsemAtlas needle,

      const Var::ArrayOfTelsemAtlas haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceTelsemAtlas since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void Extract(

            Workspace& ws,

            Var::QuantumIdentifier needle,

      const Var::ArrayOfQuantumIdentifier haystack,

      const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceQuantumIdentifier since it is output of Extract");

  }


  Extract(needle.value(), haystack.value(), index.value(), Var::verbosity(ws).value());

}


inline void ExtractFromMetaSingleScatSpecies(

            Workspace& ws,

            Var::Vector meta_param,

      const Var::String meta_name,

      const Var::Index scat_species_index) {

  if (meta_param.islast()) {

    throw std::runtime_error("meta_param needs to be a defined WorkspaceVector since it is output of ExtractFromMetaSingleScatSpecies");

  }


  ExtractFromMetaSingleScatSpecies(meta_param.value(), Var::scat_meta(ws).value(), meta_name.value(), scat_species_index.value(), Var::verbosity(ws).value());

}


inline void ext_matAddGas(

            Workspace& ws) {

  ext_matAddGas(Var::ext_mat(ws).value(), Var::propmat_clearsky(ws).value(), Var::verbosity(ws).value());

}


inline void FastemStandAlone(

            Workspace& ws,

            Var::Matrix emissivity,

            Var::Matrix reflectivity,

      const Var::Numeric za,

      const Var::Numeric wind_speed,

      const Var::Numeric rel_aa,

      const Var::Vector transmittance,

      const Var::Numeric salinity=Group::Numeric{0.035},

      const Var::Index fastem_version=Group::Index{6}) {

  if (emissivity.islast()) {

    throw std::runtime_error("emissivity needs to be a defined WorkspaceMatrix since it is output of FastemStandAlone");

  } if (reflectivity.islast()) {

    throw std::runtime_error("reflectivity needs to be a defined WorkspaceMatrix since it is output of FastemStandAlone");

  }


  FastemStandAlone(emissivity.value(), reflectivity.value(), Var::f_grid(ws).value(), Var::surface_skin_t(ws).value(), za.value(), salinity.value(), wind_speed.value(), rel_aa.value(), transmittance.value(), fastem_version.value(), Var::verbosity(ws).value());

}


inline void FieldFromGriddedField(

            Workspace& ws,

            Var::Matrix out,

      const Var::GriddedField2 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of FieldFromGriddedField");

  }


  FieldFromGriddedField(out.value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), in.value(), Var::verbosity(ws).value());

}


inline void FieldFromGriddedField(

            Workspace& ws,

            Var::Tensor3 out,

      const Var::GriddedField3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of FieldFromGriddedField");

  }


  FieldFromGriddedField(out.value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), in.value(), Var::verbosity(ws).value());

}


inline void FieldFromGriddedField(

            Workspace& ws,

            Var::Tensor4 out,

      const Var::GriddedField4 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of FieldFromGriddedField");

  }


  FieldFromGriddedField(out.value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), in.value(), Var::verbosity(ws).value());

}


inline void FieldFromGriddedField(

            Workspace& ws,

            Var::Tensor4 out,

      const Var::ArrayOfGriddedField3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of FieldFromGriddedField");

  }


  FieldFromGriddedField(out.value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), in.value(), Var::verbosity(ws).value());

}


inline void FlagOff(

            Workspace& ws,

            Var::Index flag) {

  if (flag.islast()) {

    throw std::runtime_error("flag needs to be a defined WorkspaceIndex since it is output of FlagOff");

  }


  FlagOff(flag.value(), Var::verbosity(ws).value());

}


inline void FlagOn(

            Workspace& ws,

            Var::Index flag) {

  if (flag.islast()) {

    throw std::runtime_error("flag needs to be a defined WorkspaceIndex since it is output of FlagOn");

  }


  FlagOn(flag.value(), Var::verbosity(ws).value());

}


inline void Flatten(

            Workspace& ws,

            Var::ArrayOfTime out,

      const Var::ArrayOfArrayOfTime in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTime since it is output of Flatten");

  }


  Flatten(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void Flatten(

            Workspace& ws,

            Var::ArrayOfVector out,

      const Var::ArrayOfArrayOfVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of Flatten");

  }


  Flatten(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void Flatten(

            Workspace& ws,

            Var::Matrix out,

      const Var::ArrayOfVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Flatten");

  }


  Flatten(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void Flatten(

            Workspace& ws,

            Var::Tensor3 out,

      const Var::ArrayOfMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Flatten");

  }


  Flatten(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void Flatten(

            Workspace& ws,

            Var::Tensor4 out,

      const Var::ArrayOfTensor3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of Flatten");

  }


  Flatten(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void Flatten(

            Workspace& ws,

            Var::Tensor5 out,

      const Var::ArrayOfTensor4 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor5 since it is output of Flatten");

  }


  Flatten(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void Flatten(

            Workspace& ws,

            Var::Tensor6 out,

      const Var::ArrayOfTensor5 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor6 since it is output of Flatten");

  }


  Flatten(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void Flatten(

            Workspace& ws,

            Var::Tensor7 out,

      const Var::ArrayOfTensor6 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor7 since it is output of Flatten");

  }


  Flatten(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void ForLoop(

            Workspace& ws,

      const Var::Index start,

      const Var::Index stop,

      const Var::Index step) {

  ForLoop(ws, Var::forloop_agenda(ws).value(), start.value(), stop.value(), step.value(), Var::verbosity(ws).value());

}


inline void FrequencyFromWavelength(

            Workspace& ws,

            Var::Numeric frequency,

      const Var::Numeric wavelength) {

  if (frequency.islast()) {

    throw std::runtime_error("frequency needs to be a defined WorkspaceNumeric since it is output of FrequencyFromWavelength");

  }


  FrequencyFromWavelength(frequency.value(), wavelength.value(), Var::verbosity(ws).value());

}


inline void FrequencyFromWavelength(

            Workspace& ws,

            Var::Vector frequency,

      const Var::Vector wavelength) {

  if (frequency.islast()) {

    throw std::runtime_error("frequency needs to be a defined WorkspaceVector since it is output of FrequencyFromWavelength");

  }


  FrequencyFromWavelength(frequency.value(), wavelength.value(), Var::verbosity(ws).value());

}


inline void FrequencyFromCGSAngularWavenumber(

            Workspace& ws,

            Var::Numeric frequency,

      const Var::Numeric angular_wavenumber) {

  if (frequency.islast()) {

    throw std::runtime_error("frequency needs to be a defined WorkspaceNumeric since it is output of FrequencyFromCGSAngularWavenumber");

  }


  FrequencyFromCGSAngularWavenumber(frequency.value(), angular_wavenumber.value(), Var::verbosity(ws).value());

}


inline void FrequencyFromCGSAngularWavenumber(

            Workspace& ws,

            Var::Vector frequency,

      const Var::Vector angular_wavenumber) {

  if (frequency.islast()) {

    throw std::runtime_error("frequency needs to be a defined WorkspaceVector since it is output of FrequencyFromCGSAngularWavenumber");

  }


  FrequencyFromCGSAngularWavenumber(frequency.value(), angular_wavenumber.value(), Var::verbosity(ws).value());

}


inline void FrequencyFromCGSKayserWavenumber(

            Workspace& ws,

            Var::Numeric frequency,

      const Var::Numeric kayser_wavenumber) {

  if (frequency.islast()) {

    throw std::runtime_error("frequency needs to be a defined WorkspaceNumeric since it is output of FrequencyFromCGSKayserWavenumber");

  }


  FrequencyFromCGSKayserWavenumber(frequency.value(), kayser_wavenumber.value(), Var::verbosity(ws).value());

}


inline void FrequencyFromCGSKayserWavenumber(

            Workspace& ws,

            Var::Vector frequency,

      const Var::Vector kayser_wavenumber) {

  if (frequency.islast()) {

    throw std::runtime_error("frequency needs to be a defined WorkspaceVector since it is output of FrequencyFromCGSKayserWavenumber");

  }


  FrequencyFromCGSKayserWavenumber(frequency.value(), kayser_wavenumber.value(), Var::verbosity(ws).value());

}


inline void f_gridFromAbsorptionLines(

            Workspace& ws,

      const Var::Index num_freqs,

      const Var::Numeric delta_f_low=Group::Numeric{-5e6},

      const Var::Numeric delta_f_upp=Group::Numeric{5e6}) {

  f_gridFromAbsorptionLines(Var::f_grid(ws).value(), Var::abs_lines_per_species(ws).value(), delta_f_low.value(), delta_f_upp.value(), num_freqs.value(), Var::verbosity(ws).value());

}


inline void f_gridFromGasAbsLookup(

            Workspace& ws) {

  f_gridFromGasAbsLookup(Var::f_grid(ws).value(), Var::abs_lookup(ws).value(), Var::verbosity(ws).value());

}


inline void f_gridFromSensorAMSU(

            Workspace& ws,

      const Var::Numeric spacing=Group::Numeric{.1e9}) {

  f_gridFromSensorAMSU(Var::f_grid(ws).value(), Var::lo_multi(ws).value(), Var::f_backend_multi(ws).value(), Var::backend_channel_response_multi(ws).value(), spacing.value(), Var::verbosity(ws).value());

}


inline void f_gridFromSensorAMSUgeneric(

            Workspace& ws,

      const Var::Numeric spacing=Group::Numeric{.1e9},

      const Var::Vector verbosityVect=Group::Vector{}) {

  f_gridFromSensorAMSUgeneric(Var::f_grid(ws).value(), Var::f_backend_multi(ws).value(), Var::backend_channel_response_multi(ws).value(), spacing.value(), verbosityVect.value(), Var::verbosity(ws).value());

}


inline void f_gridFromSensorHIRS(

            Workspace& ws,

      const Var::Numeric spacing=Group::Numeric{5e8}) {

  f_gridFromSensorHIRS(Var::f_grid(ws).value(), Var::f_backend(ws).value(), Var::backend_channel_response(ws).value(), spacing.value(), Var::verbosity(ws).value());

}


inline void f_gridMetMM(

            Workspace& ws,

      const Var::Vector freq_spacing=Group::Vector{{.1e9}},

      const Var::ArrayOfIndex freq_number=Group::ArrayOfIndex{{-1}},

      const Var::Numeric freq_merge_threshold=Group::Numeric{1}) {

  f_gridMetMM(Var::f_grid(ws).value(), Var::f_backend(ws).value(), Var::channel2fgrid_indexes(ws).value(), Var::channel2fgrid_weights(ws).value(), Var::met_mm_backend(ws).value(), freq_spacing.value(), freq_number.value(), freq_merge_threshold.value(), Var::verbosity(ws).value());

}


inline void g0Earth(

            Workspace& ws) {

  g0Earth(Var::g0(ws).value(), Var::lat(ws).value(), Var::verbosity(ws).value());

}


inline void g0Io(

            Workspace& ws) {

  g0Io(Var::g0(ws).value(), Var::verbosity(ws).value());

}


inline void g0Jupiter(

            Workspace& ws) {

  g0Jupiter(Var::g0(ws).value(), Var::verbosity(ws).value());

}


inline void g0Mars(

            Workspace& ws) {

  g0Mars(Var::g0(ws).value(), Var::verbosity(ws).value());

}


inline void g0Venus(

            Workspace& ws) {

  g0Venus(Var::g0(ws).value(), Var::verbosity(ws).value());

}


inline void geo_posEndOfPpath(

            Workspace& ws) {

  geo_posEndOfPpath(Var::geo_pos(ws).value(), Var::ppath(ws).value(), Var::verbosity(ws).value());

}


inline void geo_posLowestAltitudeOfPpath(

            Workspace& ws) {

  geo_posLowestAltitudeOfPpath(Var::geo_pos(ws).value(), Var::ppath(ws).value(), Var::verbosity(ws).value());

}


inline void geo_posWherePpathPassesZref(

            Workspace& ws,

      const Var::Numeric z_ref) {

  geo_posWherePpathPassesZref(Var::geo_pos(ws).value(), Var::ppath(ws).value(), z_ref.value(), Var::verbosity(ws).value());

}


inline void GetEnvironmentVariable(

            Workspace& ws,

            Var::String out,

      const Var::String in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceString since it is output of GetEnvironmentVariable");

  }


  GetEnvironmentVariable(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void GetEnvironmentVariable(

            Workspace& ws,

            Var::Index out,

      const Var::String in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of GetEnvironmentVariable");

  }


  GetEnvironmentVariable(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void GetNumberOfThreads(

            Workspace& ws,

            Var::Index nthreads) {

  if (nthreads.islast()) {

    throw std::runtime_error("nthreads needs to be a defined WorkspaceIndex since it is output of GetNumberOfThreads");

  }


  GetNumberOfThreads(nthreads.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldGetName(

            Workspace& ws,

            Var::String name,

      const Var::GriddedField1 griddedfield) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is output of GriddedFieldGetName");

  }


  GriddedFieldGetName(name.value(), griddedfield.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldGetName(

            Workspace& ws,

            Var::String name,

      const Var::GriddedField2 griddedfield) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is output of GriddedFieldGetName");

  }


  GriddedFieldGetName(name.value(), griddedfield.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldGetName(

            Workspace& ws,

            Var::String name,

      const Var::GriddedField3 griddedfield) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is output of GriddedFieldGetName");

  }


  GriddedFieldGetName(name.value(), griddedfield.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldGetName(

            Workspace& ws,

            Var::String name,

      const Var::GriddedField4 griddedfield) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is output of GriddedFieldGetName");

  }


  GriddedFieldGetName(name.value(), griddedfield.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldGetName(

            Workspace& ws,

            Var::String name,

      const Var::GriddedField5 griddedfield) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is output of GriddedFieldGetName");

  }


  GriddedFieldGetName(name.value(), griddedfield.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldGetName(

            Workspace& ws,

            Var::String name,

      const Var::GriddedField6 griddedfield) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is output of GriddedFieldGetName");

  }


  GriddedFieldGetName(name.value(), griddedfield.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldLatLonExpand(

            Workspace& ws,

            Var::GriddedField2 out,

      const Var::GriddedField2 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField2 since it is output of GriddedFieldLatLonExpand");

  }


  GriddedFieldLatLonExpand(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldLatLonExpand(

            Workspace& ws,

            Var::GriddedField3 out,

      const Var::GriddedField3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField3 since it is output of GriddedFieldLatLonExpand");

  }


  GriddedFieldLatLonExpand(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldLatLonExpand(

            Workspace& ws,

            Var::GriddedField4 out,

      const Var::GriddedField4 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField4 since it is output of GriddedFieldLatLonExpand");

  }


  GriddedFieldLatLonExpand(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldLatLonExpand(

            Workspace& ws,

            Var::ArrayOfGriddedField3 out,

      const Var::ArrayOfGriddedField3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of GriddedFieldLatLonExpand");

  }


  GriddedFieldLatLonExpand(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldLatLonRegrid(

            Workspace& ws,

            Var::GriddedField2 out,

      const Var::GriddedField2 in,

      const Var::Index interp_order=Group::Index{1}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField2 since it is output of GriddedFieldLatLonRegrid");

  }


  GriddedFieldLatLonRegrid(out.value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), in.value(), interp_order.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldLatLonRegrid(

            Workspace& ws,

            Var::GriddedField3 out,

      const Var::GriddedField3 in,

      const Var::Index interp_order=Group::Index{1}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField3 since it is output of GriddedFieldLatLonRegrid");

  }


  GriddedFieldLatLonRegrid(out.value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), in.value(), interp_order.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldLatLonRegrid(

            Workspace& ws,

            Var::GriddedField4 out,

      const Var::GriddedField4 in,

      const Var::Index interp_order=Group::Index{1}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField4 since it is output of GriddedFieldLatLonRegrid");

  }


  GriddedFieldLatLonRegrid(out.value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), in.value(), interp_order.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldLatLonRegrid(

            Workspace& ws,

            Var::ArrayOfGriddedField3 out,

      const Var::ArrayOfGriddedField3 in,

      const Var::Index interp_order=Group::Index{1}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of GriddedFieldLatLonRegrid");

  }


  GriddedFieldLatLonRegrid(out.value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), in.value(), interp_order.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldPRegrid(

            Workspace& ws,

            Var::GriddedField3 out,

      const Var::GriddedField3 in,

      const Var::Index interp_order=Group::Index{1},

      const Var::Index zeropadding=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField3 since it is output of GriddedFieldPRegrid");

  }


  GriddedFieldPRegrid(out.value(), Var::p_grid(ws).value(), in.value(), interp_order.value(), zeropadding.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldPRegrid(

            Workspace& ws,

            Var::GriddedField4 out,

      const Var::GriddedField4 in,

      const Var::Index interp_order=Group::Index{1},

      const Var::Index zeropadding=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField4 since it is output of GriddedFieldPRegrid");

  }


  GriddedFieldPRegrid(out.value(), Var::p_grid(ws).value(), in.value(), interp_order.value(), zeropadding.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldPRegrid(

            Workspace& ws,

            Var::ArrayOfGriddedField3 out,

      const Var::ArrayOfGriddedField3 in,

      const Var::Index interp_order=Group::Index{1},

      const Var::Index zeropadding=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of GriddedFieldPRegrid");

  }


  GriddedFieldPRegrid(out.value(), Var::p_grid(ws).value(), in.value(), interp_order.value(), zeropadding.value(), Var::verbosity(ws).value());

}


inline void GriddedFieldZToPRegrid(

            Workspace& ws,

            Var::GriddedField3 out,

      const Var::GriddedField3 in,

      const Var::Index interp_order=Group::Index{1},

      const Var::Index zeropadding=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField3 since it is output of GriddedFieldZToPRegrid");

  }


  GriddedFieldZToPRegrid(out.value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), in.value(), interp_order.value(), zeropadding.value(), Var::verbosity(ws).value());

}


inline void heating_ratesFromIrradiance(

            Workspace& ws) {

  heating_ratesFromIrradiance(Var::heating_rates(ws).value(), Var::p_grid(ws).value(), Var::irradiance_field(ws).value(), Var::specific_heat_capacity(ws).value(), Var::g0(ws).value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::AbsorptionLines in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Agenda in) {

  Ignore(ws, in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfAbsorptionLines in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfAbsorptionLines in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfAgenda in) {

  Ignore(ws, in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField1 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField2 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField3 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfIndex in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfMatrix in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfPpath in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfPropagationMatrix in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfRadiationVector in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfScatteringMetaData in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfSingleScatteringData in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfSpeciesTag in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfStokesVector in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfString in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor3 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor6 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfTime in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfTransmissionMatrix in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfArrayOfVector in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfCIARecord in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfGriddedField1 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfGriddedField2 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfGriddedField3 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfGriddedField4 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfIndex in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfMatrix in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfPropagationMatrix in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfRadiationVector in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfRetrievalQuantity in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfScatteringMetaData in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfSingleScatteringData in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfSparse in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfStokesVector in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfString in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfTelsemAtlas in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfTensor3 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfTensor4 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfTensor5 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfTensor6 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfTensor7 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfTime in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfTransmissionMatrix in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfVector in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ArrayOfXsecRecord in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::CIARecord in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::CovarianceMatrix in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::EnergyLevelMap in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::GasAbsLookup in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::GridPos in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::GriddedField1 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::GriddedField2 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::GriddedField3 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::GriddedField4 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::GriddedField5 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::GriddedField6 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::HitranRelaxationMatrixData in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Index in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::MCAntenna in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Matrix in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Numeric in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Ppath in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::PropagationMatrix in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::QuantumIdentifier in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::RadiationVector in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Rational in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::ScatteringMetaData in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::SingleScatteringData in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Sparse in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::SpeciesAuxData in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::StokesVector in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::String in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::TelsemAtlas in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Tensor3 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Tensor4 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Tensor5 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Tensor6 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Tensor7 in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Timer in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Time in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::TessemNN in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::TransmissionMatrix in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Vector in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void Ignore(

            Workspace& ws,

      const Var::Verbosity in) {

  Ignore(in.value(), Var::verbosity(ws).value());

}


inline void INCLUDE(

            Workspace& ws) {

  INCLUDE(Var::verbosity(ws).value());

}


inline void IndexAdd(

            Workspace& ws,

            Var::Index out,

      const Var::Index in,

      const Var::Index value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of IndexAdd");

  }


  IndexAdd(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void IndexNumberOfAtmosphericPoints(

            Workspace& ws,

            Var::Index n) {

  if (n.islast()) {

    throw std::runtime_error("n needs to be a defined WorkspaceIndex since it is output of IndexNumberOfAtmosphericPoints");

  }


  IndexNumberOfAtmosphericPoints(n.value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::verbosity(ws).value());

}


inline void IndexSet(

            Workspace& ws,

            Var::Index out,

      const Var::Index value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of IndexSet");

  }


  IndexSet(out.value(), value.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfAbsorptionLines v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfAbsorptionLines v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfAgenda v) {

  IndexSetToLast(ws, Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField1 v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField2 v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField3 v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfIndex v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfMatrix v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfPpath v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfPropagationMatrix v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfRadiationVector v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfScatteringMetaData v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfSingleScatteringData v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfSpeciesTag v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfStokesVector v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfString v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor3 v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor6 v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfTime v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfTransmissionMatrix v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfArrayOfVector v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfCIARecord v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfGriddedField1 v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfGriddedField2 v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfGriddedField3 v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfGriddedField4 v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfIndex v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfMatrix v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfPropagationMatrix v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfRadiationVector v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfRetrievalQuantity v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfScatteringMetaData v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfSingleScatteringData v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfSparse v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfStokesVector v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfString v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfTelsemAtlas v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfTensor3 v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfTensor4 v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfTensor5 v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfTensor6 v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfTensor7 v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfTime v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfTransmissionMatrix v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfVector v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::ArrayOfXsecRecord v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexSetToLast(

            Workspace& ws,

      const Var::Vector v) {

  IndexSetToLast(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void IndexStepDown(

            Workspace& ws,

            Var::Index out,

      const Var::Index in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of IndexStepDown");

  }


  IndexStepDown(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void IndexStepUp(

            Workspace& ws,

            Var::Index out,

      const Var::Index in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of IndexStepUp");

  }


  IndexStepUp(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void InterpAtmFieldToPosition(

            Workspace& ws,

            Var::Numeric out,

      const Var::Tensor3 field) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of InterpAtmFieldToPosition");

  }


  InterpAtmFieldToPosition(out.value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::rtp_pos(ws).value(), field.value(), Var::verbosity(ws).value());

}


inline void InterpGriddedField2ToPosition(

            Workspace& ws,

            Var::Numeric out,

      const Var::GriddedField2 gfield2) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of InterpGriddedField2ToPosition");

  }


  InterpGriddedField2ToPosition(out.value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), Var::rtp_pos(ws).value(), gfield2.value(), Var::verbosity(ws).value());

}


inline void InterpSurfaceFieldToPosition(

            Workspace& ws,

            Var::Numeric out,

      const Var::Matrix field) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of InterpSurfaceFieldToPosition");

  }


  InterpSurfaceFieldToPosition(out.value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::rtp_pos(ws).value(), Var::z_surface(ws).value(), field.value(), Var::verbosity(ws).value());

}


inline void irradiance_fieldFromRadiance(

            Workspace& ws) {

  irradiance_fieldFromRadiance(Var::irradiance_field(ws).value(), Var::radiance_field(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::za_grid_weights(ws).value(), Var::verbosity(ws).value());

}


inline void isotopologue_ratiosInitFromBuiltin(

            Workspace& ws) {

  isotopologue_ratiosInitFromBuiltin(Var::isotopologue_ratios(ws).value(), Var::verbosity(ws).value());

}


inline void iyActiveSingleScat(

            Workspace& ws,

      const Var::Index trans_in_jacobian=Group::Index{0},

      const Var::Numeric pext_scaling=Group::Numeric{1},

      const Var::Index t_interp_order=Group::Index{1}) {

  iyActiveSingleScat(ws, Var::iy(ws).value(), Var::iy_aux(ws).value(), Var::diy_dx(ws).value(), Var::ppvar_p(ws).value(), Var::ppvar_t(ws).value(), Var::ppvar_nlte(ws).value(), Var::ppvar_vmr(ws).value(), Var::ppvar_wind(ws).value(), Var::ppvar_mag(ws).value(), Var::ppvar_pnd(ws).value(), Var::ppvar_f(ws).value(), Var::ppvar_trans_cumulat(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::t_field(ws).value(), Var::nlte_field(ws).value(), Var::vmr_field(ws).value(), Var::abs_species(ws).value(), Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::pnd_field(ws).value(), Var::dpnd_field_dx(ws).value(), Var::scat_species(ws).value(), Var::scat_data(ws).value(), Var::scat_data_checked(ws).value(), Var::iy_aux_vars(ws).value(), Var::jacobian_do(ws).value(), Var::jacobian_quantities(ws).value(), Var::ppath(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::water_p_eq_agenda(ws).value(), Var::iy_transmitter_agenda(ws).value(), Var::iy_agenda_call1(ws).value(), Var::iy_transmission(ws).value(), Var::rte_alonglos_v(ws).value(), trans_in_jacobian.value(), pext_scaling.value(), t_interp_order.value(), Var::verbosity(ws).value());

}


inline void iyActiveSingleScat2(

            Workspace& ws,

      const Var::Index trans_in_jacobian=Group::Index{0},

      const Var::Numeric pext_scaling=Group::Numeric{1},

      const Var::Index t_interp_order=Group::Index{1}) {

  iyActiveSingleScat2(ws, Var::iy(ws).value(), Var::iy_aux(ws).value(), Var::diy_dx(ws).value(), Var::ppvar_p(ws).value(), Var::ppvar_t(ws).value(), Var::ppvar_nlte(ws).value(), Var::ppvar_vmr(ws).value(), Var::ppvar_wind(ws).value(), Var::ppvar_mag(ws).value(), Var::ppvar_pnd(ws).value(), Var::ppvar_f(ws).value(), Var::ppvar_trans_cumulat(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::t_field(ws).value(), Var::nlte_field(ws).value(), Var::vmr_field(ws).value(), Var::abs_species(ws).value(), Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::pnd_field(ws).value(), Var::dpnd_field_dx(ws).value(), Var::scat_species(ws).value(), Var::scat_data(ws).value(), Var::scat_data_checked(ws).value(), Var::iy_aux_vars(ws).value(), Var::jacobian_do(ws).value(), Var::jacobian_quantities(ws).value(), Var::ppath(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::water_p_eq_agenda(ws).value(), Var::iy_transmitter_agenda(ws).value(), Var::iy_agenda_call1(ws).value(), Var::iy_transmission(ws).value(), Var::rte_alonglos_v(ws).value(), trans_in_jacobian.value(), pext_scaling.value(), t_interp_order.value(), Var::verbosity(ws).value());

}


inline void iyApplyUnit(

            Workspace& ws) {

  iyApplyUnit(Var::iy(ws).value(), Var::iy_aux(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::iy_aux_vars(ws).value(), Var::iy_unit(ws).value(), Var::verbosity(ws).value());

}


inline void iyCalc(

            Workspace& ws) {

  iyCalc(ws, Var::iy(ws).value(), Var::iy_aux(ws).value(), Var::ppath(ws).value(), Var::atmgeom_checked(ws).value(), Var::atmfields_checked(ws).value(), Var::iy_aux_vars(ws).value(), Var::iy_id(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_checked(ws).value(), Var::scat_data_checked(ws).value(), Var::f_grid(ws).value(), Var::nlte_field(ws).value(), Var::rte_pos(ws).value(), Var::rte_los(ws).value(), Var::rte_pos2(ws).value(), Var::iy_unit(ws).value(), Var::iy_main_agenda(ws).value(), Var::verbosity(ws).value());

}


inline void iyEmissionStandard(

            Workspace& ws) {

  iyEmissionStandard(ws, Var::iy(ws).value(), Var::iy_aux(ws).value(), Var::diy_dx(ws).value(), Var::ppvar_p(ws).value(), Var::ppvar_t(ws).value(), Var::ppvar_nlte(ws).value(), Var::ppvar_vmr(ws).value(), Var::ppvar_wind(ws).value(), Var::ppvar_mag(ws).value(), Var::ppvar_f(ws).value(), Var::ppvar_iy(ws).value(), Var::ppvar_trans_cumulat(ws).value(), Var::ppvar_trans_partial(ws).value(), Var::iy_id(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::t_field(ws).value(), Var::nlte_field(ws).value(), Var::vmr_field(ws).value(), Var::abs_species(ws).value(), Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::cloudbox_on(ws).value(), Var::iy_unit(ws).value(), Var::iy_aux_vars(ws).value(), Var::jacobian_do(ws).value(), Var::jacobian_quantities(ws).value(), Var::ppath(ws).value(), Var::rte_pos2(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::water_p_eq_agenda(ws).value(), Var::iy_main_agenda(ws).value(), Var::iy_space_agenda(ws).value(), Var::iy_surface_agenda(ws).value(), Var::iy_cloudbox_agenda(ws).value(), Var::iy_agenda_call1(ws).value(), Var::iy_transmission(ws).value(), Var::rte_alonglos_v(ws).value(), Var::surface_props_data(ws).value(), Var::verbosity(ws).value());

}


inline void iyEmissionStandardSequential(

            Workspace& ws) {

  iyEmissionStandardSequential(ws, Var::iy(ws).value(), Var::iy_aux(ws).value(), Var::diy_dx(ws).value(), Var::ppvar_p(ws).value(), Var::ppvar_t(ws).value(), Var::ppvar_nlte(ws).value(), Var::ppvar_vmr(ws).value(), Var::ppvar_wind(ws).value(), Var::ppvar_mag(ws).value(), Var::ppvar_f(ws).value(), Var::ppvar_iy(ws).value(), Var::ppvar_trans_cumulat(ws).value(), Var::ppvar_trans_partial(ws).value(), Var::iy_id(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::t_field(ws).value(), Var::nlte_field(ws).value(), Var::vmr_field(ws).value(), Var::abs_species(ws).value(), Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::cloudbox_on(ws).value(), Var::iy_unit(ws).value(), Var::iy_aux_vars(ws).value(), Var::jacobian_do(ws).value(), Var::jacobian_quantities(ws).value(), Var::ppath(ws).value(), Var::rte_pos2(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::water_p_eq_agenda(ws).value(), Var::iy_main_agenda(ws).value(), Var::iy_space_agenda(ws).value(), Var::iy_surface_agenda(ws).value(), Var::iy_cloudbox_agenda(ws).value(), Var::iy_agenda_call1(ws).value(), Var::iy_transmission(ws).value(), Var::rte_alonglos_v(ws).value(), Var::surface_props_data(ws).value(), Var::verbosity(ws).value());

}


inline void iyHybrid(

            Workspace& ws,

      const Var::Index Naa_grid=Group::Index{19},

      const Var::Index t_interp_order=Group::Index{1}) {

  iyHybrid(ws, Var::iy(ws).value(), Var::iy_aux(ws).value(), Var::diy_dx(ws).value(), Var::ppvar_p(ws).value(), Var::ppvar_t(ws).value(), Var::ppvar_nlte(ws).value(), Var::ppvar_vmr(ws).value(), Var::ppvar_wind(ws).value(), Var::ppvar_mag(ws).value(), Var::ppvar_pnd(ws).value(), Var::ppvar_f(ws).value(), Var::ppvar_iy(ws).value(), Var::ppvar_trans_cumulat(ws).value(), Var::iy_id(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::t_field(ws).value(), Var::nlte_field(ws).value(), Var::vmr_field(ws).value(), Var::abs_species(ws).value(), Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::pnd_field(ws).value(), Var::dpnd_field_dx(ws).value(), Var::scat_species(ws).value(), Var::scat_data(ws).value(), Var::iy_unit(ws).value(), Var::iy_aux_vars(ws).value(), Var::jacobian_do(ws).value(), Var::jacobian_quantities(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::water_p_eq_agenda(ws).value(), Var::iy_main_agenda(ws).value(), Var::iy_space_agenda(ws).value(), Var::iy_surface_agenda(ws).value(), Var::iy_cloudbox_agenda(ws).value(), Var::iy_agenda_call1(ws).value(), Var::iy_transmission(ws).value(), Var::ppath(ws).value(), Var::rte_pos2(ws).value(), Var::rte_alonglos_v(ws).value(), Var::surface_props_data(ws).value(), Var::cloudbox_field(ws).value(), Var::za_grid(ws).value(), Naa_grid.value(), t_interp_order.value(), Var::verbosity(ws).value());

}


inline void iyHybrid2(

            Workspace& ws,

      const Var::Index Naa_grid=Group::Index{19},

      const Var::Index t_interp_order=Group::Index{1}) {

  iyHybrid2(ws, Var::iy(ws).value(), Var::iy_aux(ws).value(), Var::diy_dx(ws).value(), Var::ppvar_p(ws).value(), Var::ppvar_t(ws).value(), Var::ppvar_nlte(ws).value(), Var::ppvar_vmr(ws).value(), Var::ppvar_wind(ws).value(), Var::ppvar_mag(ws).value(), Var::ppvar_pnd(ws).value(), Var::ppvar_f(ws).value(), Var::ppvar_iy(ws).value(), Var::ppvar_trans_cumulat(ws).value(), Var::iy_id(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::t_field(ws).value(), Var::nlte_field(ws).value(), Var::vmr_field(ws).value(), Var::abs_species(ws).value(), Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::pnd_field(ws).value(), Var::dpnd_field_dx(ws).value(), Var::scat_species(ws).value(), Var::scat_data(ws).value(), Var::iy_unit(ws).value(), Var::iy_aux_vars(ws).value(), Var::jacobian_do(ws).value(), Var::jacobian_quantities(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::water_p_eq_agenda(ws).value(), Var::iy_main_agenda(ws).value(), Var::iy_space_agenda(ws).value(), Var::iy_surface_agenda(ws).value(), Var::iy_cloudbox_agenda(ws).value(), Var::iy_agenda_call1(ws).value(), Var::iy_transmission(ws).value(), Var::ppath(ws).value(), Var::rte_pos2(ws).value(), Var::rte_alonglos_v(ws).value(), Var::surface_props_data(ws).value(), Var::cloudbox_field(ws).value(), Var::za_grid(ws).value(), Naa_grid.value(), t_interp_order.value(), Var::verbosity(ws).value());

}


inline void iyIndependentBeamApproximation(

            Workspace& ws,

      const Var::Index return_atm1d=Group::Index{0},

      const Var::Index skip_vmr=Group::Index{0},

      const Var::Index skip_pnd=Group::Index{0},

      const Var::Index return_masses=Group::Index{0}) {

  iyIndependentBeamApproximation(ws, Var::iy(ws).value(), Var::iy_aux(ws).value(), Var::ppath(ws).value(), Var::diy_dx(ws).value(), Var::atm_fields_compact(ws).value(), Var::iy_id(ws).value(), Var::f_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), Var::t_field(ws).value(), Var::z_field(ws).value(), Var::vmr_field(ws).value(), Var::nlte_field(ws).value(), Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::pnd_field(ws).value(), Var::particle_masses(ws).value(), Var::ppath_agenda(ws).value(), Var::ppath_lmax(ws).value(), Var::ppath_lraytrace(ws).value(), Var::iy_agenda_call1(ws).value(), Var::iy_unit(ws).value(), Var::iy_transmission(ws).value(), Var::rte_pos(ws).value(), Var::rte_los(ws).value(), Var::rte_pos2(ws).value(), Var::jacobian_do(ws).value(), Var::iy_aux_vars(ws).value(), Var::iy_independent_beam_approx_agenda(ws).value(), return_atm1d.value(), skip_vmr.value(), skip_pnd.value(), return_masses.value(), Var::verbosity(ws).value());

}


inline void iyInterpCloudboxField(

            Workspace& ws,

      const Var::Index za_interp_order=Group::Index{1},

      const Var::Index za_restrict=Group::Index{1},

      const Var::Index cos_za_interp=Group::Index{0},

      const Var::Numeric za_extpolfac=Group::Numeric{0.5},

      const Var::Index aa_interp_order=Group::Index{1}) {

  iyInterpCloudboxField(Var::iy(ws).value(), Var::cloudbox_field(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::jacobian_do(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::z_surface(ws).value(), Var::stokes_dim(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::f_grid(ws).value(), za_interp_order.value(), za_restrict.value(), cos_za_interp.value(), za_extpolfac.value(), aa_interp_order.value(), Var::verbosity(ws).value());

}


inline void iyLoopFrequencies(

            Workspace& ws) {

  iyLoopFrequencies(ws, Var::iy(ws).value(), Var::iy_aux(ws).value(), Var::ppath(ws).value(), Var::diy_dx(ws).value(), Var::iy_aux_vars(ws).value(), Var::iy_agenda_call1(ws).value(), Var::iy_transmission(ws).value(), Var::rte_pos(ws).value(), Var::rte_los(ws).value(), Var::rte_pos2(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::iy_loop_freqs_agenda(ws).value(), Var::verbosity(ws).value());

}


inline void iyMC(

            Workspace& ws,

      const Var::Index t_interp_order=Group::Index{1}) {

  iyMC(ws, Var::iy(ws).value(), Var::iy_aux(ws).value(), Var::diy_dx(ws).value(), Var::iy_agenda_call1(ws).value(), Var::iy_transmission(ws).value(), Var::rte_pos(ws).value(), Var::rte_los(ws).value(), Var::iy_aux_vars(ws).value(), Var::jacobian_do(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::t_field(ws).value(), Var::vmr_field(ws).value(), Var::refellipsoid(ws).value(), Var::z_surface(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::scat_data(ws).value(), Var::iy_space_agenda(ws).value(), Var::surface_rtprop_agenda(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::ppath_step_agenda(ws).value(), Var::ppath_lmax(ws).value(), Var::ppath_lraytrace(ws).value(), Var::pnd_field(ws).value(), Var::iy_unit(ws).value(), Var::mc_std_err(ws).value(), Var::mc_max_time(ws).value(), Var::mc_max_iter(ws).value(), Var::mc_min_iter(ws).value(), Var::mc_taustep_limit(ws).value(), t_interp_order.value(), Var::verbosity(ws).value());

}


inline void iyReplaceFromAux(

            Workspace& ws,

      const Var::String aux_var) {

  iyReplaceFromAux(Var::iy(ws).value(), Var::iy_aux(ws).value(), Var::iy_aux_vars(ws).value(), Var::jacobian_do(ws).value(), aux_var.value(), Var::verbosity(ws).value());

}


inline void iySurfaceCallAgendaX(

            Workspace& ws) {

  iySurfaceCallAgendaX(ws, Var::iy(ws).value(), Var::diy_dx(ws).value(), Var::iy_unit(ws).value(), Var::iy_transmission(ws).value(), Var::iy_id(ws).value(), Var::cloudbox_on(ws).value(), Var::jacobian_do(ws).value(), Var::f_grid(ws).value(), Var::iy_main_agenda(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::rte_pos2(ws).value(), Var::iy_surface_agenda_array(ws).value(), Var::surface_type(ws).value(), Var::surface_type_aux(ws).value(), Var::verbosity(ws).value());

}


inline void iySurfaceFastem(

            Workspace& ws,

      const Var::Numeric wind_speed,

      const Var::Numeric salinity=Group::Numeric{0.035},

      const Var::Numeric wind_direction=Group::Numeric{0},

      const Var::Index fastem_version=Group::Index{6}) {

  iySurfaceFastem(ws, Var::iy(ws).value(), Var::diy_dx(ws).value(), Var::iy_transmission(ws).value(), Var::iy_id(ws).value(), Var::jacobian_do(ws).value(), Var::atmosphere_dim(ws).value(), Var::nlte_field(ws).value(), Var::cloudbox_on(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::rte_pos2(ws).value(), Var::iy_unit(ws).value(), Var::iy_main_agenda(ws).value(), Var::surface_skin_t(ws).value(), salinity.value(), wind_speed.value(), wind_direction.value(), fastem_version.value(), Var::verbosity(ws).value());

}


inline void iySurfaceRtpropAgenda(

            Workspace& ws) {

  iySurfaceRtpropAgenda(ws, Var::iy(ws).value(), Var::diy_dx(ws).value(), Var::iy_transmission(ws).value(), Var::iy_id(ws).value(), Var::jacobian_do(ws).value(), Var::atmosphere_dim(ws).value(), Var::nlte_field(ws).value(), Var::cloudbox_on(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::rte_pos2(ws).value(), Var::iy_unit(ws).value(), Var::iy_main_agenda(ws).value(), Var::surface_rtprop_agenda(ws).value(), Var::verbosity(ws).value());

}


inline void iySurfaceRtpropCalc(

            Workspace& ws) {

  iySurfaceRtpropCalc(ws, Var::iy(ws).value(), Var::diy_dx(ws).value(), Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::surface_emission(ws).value(), Var::dsurface_names(ws).value(), Var::dsurface_rmatrix_dx(ws).value(), Var::dsurface_emission_dx(ws).value(), Var::iy_transmission(ws).value(), Var::iy_id(ws).value(), Var::jacobian_do(ws).value(), Var::jacobian_quantities(ws).value(), Var::atmosphere_dim(ws).value(), Var::nlte_field(ws).value(), Var::cloudbox_on(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::rte_pos2(ws).value(), Var::iy_unit(ws).value(), Var::iy_main_agenda(ws).value(), Var::verbosity(ws).value());

}


inline void iyTransmissionStandard(

            Workspace& ws) {

  iyTransmissionStandard(ws, Var::iy(ws).value(), Var::iy_aux(ws).value(), Var::diy_dx(ws).value(), Var::ppvar_p(ws).value(), Var::ppvar_t(ws).value(), Var::ppvar_nlte(ws).value(), Var::ppvar_vmr(ws).value(), Var::ppvar_wind(ws).value(), Var::ppvar_mag(ws).value(), Var::ppvar_pnd(ws).value(), Var::ppvar_f(ws).value(), Var::ppvar_iy(ws).value(), Var::ppvar_trans_cumulat(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::t_field(ws).value(), Var::nlte_field(ws).value(), Var::vmr_field(ws).value(), Var::abs_species(ws).value(), Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::pnd_field(ws).value(), Var::dpnd_field_dx(ws).value(), Var::scat_species(ws).value(), Var::scat_data(ws).value(), Var::iy_aux_vars(ws).value(), Var::jacobian_do(ws).value(), Var::jacobian_quantities(ws).value(), Var::ppath(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::water_p_eq_agenda(ws).value(), Var::iy_transmitter_agenda(ws).value(), Var::iy_agenda_call1(ws).value(), Var::iy_transmission(ws).value(), Var::rte_alonglos_v(ws).value(), Var::verbosity(ws).value());

}


inline void iy_transmitterMultiplePol(

            Workspace& ws) {

  iy_transmitterMultiplePol(Var::iy(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::instrument_pol(ws).value(), Var::verbosity(ws).value());

}


inline void iy_transmitterSinglePol(

            Workspace& ws) {

  iy_transmitterSinglePol(Var::iy(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::instrument_pol(ws).value(), Var::verbosity(ws).value());

}


inline void jacobianAddAbsSpecies(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::Vector g3,

      const Var::String species,

      const Var::String unit=Group::String{"vmr"},

      const Var::Index for_species_tag=Group::Index{1}) {

  jacobianAddAbsSpecies(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), g3.value(), species.value(), unit.value(), for_species_tag.value(), Var::verbosity(ws).value());

}


inline void jacobianAddBasicCatalogParameter(

            Workspace& ws,

      const Var::QuantumIdentifier catalog_identity,

      const Var::String catalog_parameter) {

  jacobianAddBasicCatalogParameter(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), catalog_identity.value(), catalog_parameter.value(), Var::verbosity(ws).value());

}


inline void jacobianAddBasicCatalogParameters(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier catalog_identities,

      const Var::ArrayOfString catalog_parameters) {

  jacobianAddBasicCatalogParameters(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), catalog_identities.value(), catalog_parameters.value(), Var::verbosity(ws).value());

}


inline void jacobianAddFreqShift(

            Workspace& ws,

      const Var::Numeric df=Group::Numeric{100e3}) {

  jacobianAddFreqShift(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::f_grid(ws).value(), df.value(), Var::verbosity(ws).value());

}


inline void jacobianAddFreqStretch(

            Workspace& ws,

      const Var::Numeric df=Group::Numeric{100e3}) {

  jacobianAddFreqStretch(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::f_grid(ws).value(), df.value(), Var::verbosity(ws).value());

}


inline void jacobianAddShapeCatalogParameter(

            Workspace& ws,

      const Var::QuantumIdentifier line_identity,

      const Var::String species,

      const Var::String variable,

      const Var::String coefficient) {

  jacobianAddShapeCatalogParameter(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), line_identity.value(), species.value(), variable.value(), coefficient.value(), Var::verbosity(ws).value());

}


inline void jacobianAddShapeCatalogParameters(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier line_identities,

      const Var::ArrayOfString species,

      const Var::ArrayOfString variables,

      const Var::ArrayOfString coefficients) {

  jacobianAddShapeCatalogParameters(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), line_identities.value(), species.value(), variables.value(), coefficients.value(), Var::verbosity(ws).value());

}


inline void jacobianAddMagField(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::Vector g3,

      const Var::String component=Group::String{"v"},

      const Var::Numeric dB=Group::Numeric{1.0e-7}) {

  jacobianAddMagField(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), g3.value(), component.value(), dB.value(), Var::verbosity(ws).value());

}


inline void jacobianAddNLTE(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::Vector g3,

      const Var::QuantumIdentifier energy_level_identity,

      const Var::Numeric dx=Group::Numeric{1.0e-3}) {

  jacobianAddNLTE(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), g3.value(), energy_level_identity.value(), dx.value(), Var::verbosity(ws).value());

}


inline void jacobianAddNLTEs(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::Vector g3,

      const Var::ArrayOfQuantumIdentifier energy_level_identities,

      const Var::Numeric dx=Group::Numeric{1.0e-3}) {

  jacobianAddNLTEs(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), g3.value(), energy_level_identities.value(), dx.value(), Var::verbosity(ws).value());

}


inline void jacobianAddPointingZa(

            Workspace& ws,

      const Var::Index poly_order=Group::Index{0},

      const Var::String calcmode=Group::String{"recalc"},

      const Var::Numeric dza=Group::Numeric{0.01}) {

  jacobianAddPointingZa(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::sensor_pos(ws).value(), Var::sensor_time(ws).value(), poly_order.value(), calcmode.value(), dza.value(), Var::verbosity(ws).value());

}


inline void jacobianAddPolyfit(

            Workspace& ws,

      const Var::Index poly_order,

      const Var::Index no_pol_variation=Group::Index{0},

      const Var::Index no_los_variation=Group::Index{0},

      const Var::Index no_mblock_variation=Group::Index{0}) {

  jacobianAddPolyfit(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::sensor_pos(ws).value(), poly_order.value(), no_pol_variation.value(), no_los_variation.value(), no_mblock_variation.value(), Var::verbosity(ws).value());

}


inline void jacobianAddScatSpecies(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::Vector g3,

      const Var::String species,

      const Var::String quantity) {

  jacobianAddScatSpecies(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), g3.value(), species.value(), quantity.value(), Var::verbosity(ws).value());

}


inline void jacobianAddSinefit(

            Workspace& ws,

      const Var::Vector period_lengths,

      const Var::Index no_pol_variation=Group::Index{0},

      const Var::Index no_los_variation=Group::Index{0},

      const Var::Index no_mblock_variation=Group::Index{0}) {

  jacobianAddSinefit(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::sensor_pos(ws).value(), period_lengths.value(), no_pol_variation.value(), no_los_variation.value(), no_mblock_variation.value(), Var::verbosity(ws).value());

}


inline void jacobianAddSpecialSpecies(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::Vector g3,

      const Var::String species) {

  jacobianAddSpecialSpecies(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), g3.value(), species.value(), Var::verbosity(ws).value());

}


inline void jacobianAddSurfaceQuantity(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::String quantity) {

  jacobianAddSurfaceQuantity(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), quantity.value(), Var::verbosity(ws).value());

}


inline void jacobianAddTemperature(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::Vector g3,

      const Var::String hse=Group::String{"on"}) {

  jacobianAddTemperature(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), g3.value(), hse.value(), Var::verbosity(ws).value());

}


inline void jacobianAddWind(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::Vector g3,

      const Var::String component=Group::String{"v"},

      const Var::Numeric dfrequency=Group::Numeric{0.1}) {

  jacobianAddWind(ws, Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), g3.value(), component.value(), dfrequency.value(), Var::verbosity(ws).value());

}


inline void jacobianAdjustAndTransform(

            Workspace& ws) {

  jacobianAdjustAndTransform(Var::jacobian(ws).value(), Var::jacobian_quantities(ws).value(), Var::x(ws).value(), Var::verbosity(ws).value());

}


inline void jacobianCalcDoNothing(

            Workspace& ws) {

  jacobianCalcDoNothing(Var::jacobian(ws).value(), Var::mblock_index(ws).value(), Var::iyb(ws).value(), Var::yb(ws).value(), Var::verbosity(ws).value());

}


inline void jacobianCalcFreqShift(

            Workspace& ws) {

  jacobianCalcFreqShift(Var::jacobian(ws).value(), Var::mblock_index(ws).value(), Var::iyb(ws).value(), Var::yb(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::sensor_response(ws).value(), Var::jacobian_quantities(ws).value(), Var::verbosity(ws).value());

}


inline void jacobianCalcFreqStretch(

            Workspace& ws) {

  jacobianCalcFreqStretch(Var::jacobian(ws).value(), Var::mblock_index(ws).value(), Var::iyb(ws).value(), Var::yb(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::sensor_response(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::jacobian_quantities(ws).value(), Var::verbosity(ws).value());

}


inline void jacobianCalcPointingZaInterp(

            Workspace& ws) {

  jacobianCalcPointingZaInterp(Var::jacobian(ws).value(), Var::mblock_index(ws).value(), Var::iyb(ws).value(), Var::yb(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::sensor_los(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::sensor_response(ws).value(), Var::sensor_time(ws).value(), Var::jacobian_quantities(ws).value(), Var::verbosity(ws).value());

}


inline void jacobianCalcPointingZaRecalc(

            Workspace& ws) {

  jacobianCalcPointingZaRecalc(ws, Var::jacobian(ws).value(), Var::mblock_index(ws).value(), Var::iyb(ws).value(), Var::yb(ws).value(), Var::atmosphere_dim(ws).value(), Var::nlte_field(ws).value(), Var::cloudbox_on(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::sensor_pos(ws).value(), Var::sensor_los(ws).value(), Var::transmitter_pos(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::sensor_response(ws).value(), Var::sensor_time(ws).value(), Var::iy_unit(ws).value(), Var::iy_main_agenda(ws).value(), Var::geo_pos_agenda(ws).value(), Var::jacobian_quantities(ws).value(), Var::verbosity(ws).value());

}


inline void jacobianCalcPolyfit(

            Workspace& ws,

      const Var::Index poly_coeff) {

  jacobianCalcPolyfit(Var::jacobian(ws).value(), Var::mblock_index(ws).value(), Var::iyb(ws).value(), Var::yb(ws).value(), Var::sensor_response(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::jacobian_quantities(ws).value(), poly_coeff.value(), Var::verbosity(ws).value());

}


inline void jacobianCalcSinefit(

            Workspace& ws,

      const Var::Index period_index) {

  jacobianCalcSinefit(Var::jacobian(ws).value(), Var::mblock_index(ws).value(), Var::iyb(ws).value(), Var::yb(ws).value(), Var::sensor_response(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::jacobian_quantities(ws).value(), period_index.value(), Var::verbosity(ws).value());

}


inline void jacobianClose(

            Workspace& ws) {

  jacobianClose(ws, Var::jacobian_do(ws).value(), Var::jacobian_agenda(ws).value(), Var::jacobian_quantities(ws).value(), Var::verbosity(ws).value());

}


inline void jacobianFromTwoY(

            Workspace& ws,

      const Var::Vector y_pert,

      const Var::Numeric pert_size) {

  jacobianFromTwoY(Var::jacobian(ws).value(), Var::y(ws).value(), y_pert.value(), pert_size.value(), Var::verbosity(ws).value());

}


inline void jacobianFromYbatch(

            Workspace& ws,

      const Var::Numeric pert_size) {

  jacobianFromYbatch(Var::jacobian(ws).value(), Var::ybatch(ws).value(), Var::y(ws).value(), pert_size.value(), Var::verbosity(ws).value());

}


inline void jacobianInit(

            Workspace& ws) {

  jacobianInit(Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::verbosity(ws).value());

}


inline void jacobianOff(

            Workspace& ws) {

  jacobianOff(Var::jacobian_do(ws).value(), Var::jacobian_agenda(ws).value(), Var::jacobian_quantities(ws).value(), Var::verbosity(ws).value());

}


inline void jacobianSetAffineTransformation(

            Workspace& ws,

      const Var::Matrix transformation_matrix,

      const Var::Vector offset_vector) {

  jacobianSetAffineTransformation(Var::jacobian_quantities(ws).value(), transformation_matrix.value(), offset_vector.value(), Var::verbosity(ws).value());

}


inline void jacobianSetFuncTransformation(

            Workspace& ws,

      const Var::String transformation_func,

      const Var::Numeric z_min=Group::Numeric{0},

      const Var::Numeric z_max=Group::Numeric{-99e99}) {

  jacobianSetFuncTransformation(Var::jacobian_quantities(ws).value(), transformation_func.value(), z_min.value(), z_max.value(), Var::verbosity(ws).value());

}


inline void lat_gridFromRawField(

            Workspace& ws,

      const Var::GriddedField3 field_raw) {

  lat_gridFromRawField(Var::lat_grid(ws).value(), field_raw.value(), Var::verbosity(ws).value());

}


inline void lbl_checkedCalc(

            Workspace& ws) {

  lbl_checkedCalc(Var::lbl_checked(ws).value(), Var::abs_lines_per_species(ws).value(), Var::abs_species(ws).value(), Var::isotopologue_ratios(ws).value(), Var::partition_functions(ws).value(), Var::verbosity(ws).value());

}


inline void LocalTimeOffset(

            Workspace& ws,

            Var::Numeric dt) {

  if (dt.islast()) {

    throw std::runtime_error("dt needs to be a defined WorkspaceNumeric since it is output of LocalTimeOffset");

  }


  LocalTimeOffset(dt.value(), Var::verbosity(ws).value());

}


inline void lon_gridFromRawField(

            Workspace& ws,

      const Var::GriddedField3 field_raw) {

  lon_gridFromRawField(Var::lon_grid(ws).value(), field_raw.value(), Var::verbosity(ws).value());

}


inline void MagFieldsCalc(

            Workspace& ws,

      const Var::Index interp_order=Group::Index{1}) {

  MagFieldsCalc(Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::mag_u_field_raw(ws).value(), Var::mag_v_field_raw(ws).value(), Var::mag_w_field_raw(ws).value(), Var::atmosphere_dim(ws).value(), interp_order.value(), Var::verbosity(ws).value());

}


inline void MagFieldsCalcExpand1D(

            Workspace& ws,

      const Var::Index interp_order=Group::Index{1}) {

  MagFieldsCalcExpand1D(Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::mag_u_field_raw(ws).value(), Var::mag_v_field_raw(ws).value(), Var::mag_w_field_raw(ws).value(), Var::atmosphere_dim(ws).value(), interp_order.value(), Var::verbosity(ws).value());

}


inline void MagFieldsFromAltitudeRawCalc(

            Workspace& ws,

      const Var::Index interp_order=Group::Index{1},

      const Var::Numeric extrapolating=Group::Numeric{1e99}) {

  MagFieldsFromAltitudeRawCalc(Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::mag_u_field_raw(ws).value(), Var::mag_v_field_raw(ws).value(), Var::mag_w_field_raw(ws).value(), interp_order.value(), extrapolating.value(), Var::verbosity(ws).value());

}


inline void MagRawRead(

            Workspace& ws,

      const Var::String basename) {

  MagRawRead(Var::mag_u_field_raw(ws).value(), Var::mag_v_field_raw(ws).value(), Var::mag_w_field_raw(ws).value(), basename.value(), Var::verbosity(ws).value());

}


inline void MatrixAddScalar(

            Workspace& ws,

            Var::Matrix out,

      const Var::Matrix in,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixAddScalar");

  }


  MatrixAddScalar(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void MatrixCBR(

            Workspace& ws,

            Var::Matrix out,

      const Var::Vector f) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixCBR");

  }


  MatrixCBR(out.value(), Var::stokes_dim(ws).value(), f.value(), Var::verbosity(ws).value());

}


inline void MatrixCopySparse(

            Workspace& ws,

            Var::Matrix out,

      const Var::Sparse in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixCopySparse");

  }


  MatrixCopySparse(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void MatrixExtractFromTensor3(

            Workspace& ws,

            Var::Matrix out,

      const Var::Tensor3 in,

      const Var::Index i,

      const Var::String direction) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixExtractFromTensor3");

  }


  MatrixExtractFromTensor3(out.value(), in.value(), i.value(), direction.value(), Var::verbosity(ws).value());

}


inline void MatrixFromCovarianceMatrix(

            Workspace& ws,

            Var::Matrix out,

      const Var::CovarianceMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixFromCovarianceMatrix");

  }


  MatrixFromCovarianceMatrix(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void MatrixIdentity(

            Workspace& ws,

            Var::Matrix out,

      const Var::Index n,

      const Var::Numeric value=Group::Numeric{1}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixIdentity");

  }


  MatrixIdentity(out.value(), n.value(), value.value(), Var::verbosity(ws).value());

}


inline void MatrixMatrixMultiply(

            Workspace& ws,

            Var::Matrix out,

      const Var::Matrix m,

      const Var::Matrix x) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixMatrixMultiply");

  }


  MatrixMatrixMultiply(out.value(), m.value(), x.value(), Var::verbosity(ws).value());

}


inline void MatrixPlanck(

            Workspace& ws,

            Var::Matrix out,

      const Var::Vector f,

      const Var::Numeric t) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixPlanck");

  }


  MatrixPlanck(out.value(), Var::stokes_dim(ws).value(), f.value(), t.value(), Var::verbosity(ws).value());

}


inline void MatrixScale(

            Workspace& ws,

            Var::Matrix out,

      const Var::Matrix in,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixScale");

  }


  MatrixScale(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void MatrixSet(

            Workspace& ws,

            Var::Matrix out,

      const Var::Matrix value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixSet");

  }


  MatrixSet(out.value(), value.value(), Var::verbosity(ws).value());

}


inline void MatrixSetConstant(

            Workspace& ws,

            Var::Matrix out,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixSetConstant");

  }


  MatrixSetConstant(out.value(), Var::nrows(ws).value(), Var::ncols(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void MatrixUnitIntensity(

            Workspace& ws,

            Var::Matrix out,

      const Var::Vector f) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixUnitIntensity");

  }


  MatrixUnitIntensity(out.value(), Var::stokes_dim(ws).value(), f.value(), Var::verbosity(ws).value());

}


inline void MatrixVectorMultiply(

            Workspace& ws,

            Var::Vector out,

      const Var::Matrix m,

      const Var::Vector v) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of MatrixVectorMultiply");

  }


  MatrixVectorMultiply(out.value(), m.value(), v.value(), Var::verbosity(ws).value());

}


inline void Matrix1ColFromVector(

            Workspace& ws,

            Var::Matrix out,

      const Var::Vector v) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Matrix1ColFromVector");

  }


  Matrix1ColFromVector(out.value(), v.value(), Var::verbosity(ws).value());

}


inline void Matrix2ColFromVectors(

            Workspace& ws,

            Var::Matrix out,

      const Var::Vector v1,

      const Var::Vector v2) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Matrix2ColFromVectors");

  }


  Matrix2ColFromVectors(out.value(), v1.value(), v2.value(), Var::verbosity(ws).value());

}


inline void Matrix3ColFromVectors(

            Workspace& ws,

            Var::Matrix out,

      const Var::Vector v1,

      const Var::Vector v2,

      const Var::Vector v3) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Matrix3ColFromVectors");

  }


  Matrix3ColFromVectors(out.value(), v1.value(), v2.value(), v3.value(), Var::verbosity(ws).value());

}


inline void Matrix1RowFromVector(

            Workspace& ws,

            Var::Matrix out,

      const Var::Vector v) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Matrix1RowFromVector");

  }


  Matrix1RowFromVector(out.value(), v.value(), Var::verbosity(ws).value());

}


inline void Matrix2RowFromVectors(

            Workspace& ws,

            Var::Matrix out,

      const Var::Vector v1,

      const Var::Vector v2) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Matrix2RowFromVectors");

  }


  Matrix2RowFromVectors(out.value(), v1.value(), v2.value(), Var::verbosity(ws).value());

}


inline void Matrix3RowFromVectors(

            Workspace& ws,

            Var::Matrix out,

      const Var::Vector v1,

      const Var::Vector v2,

      const Var::Vector v3) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Matrix3RowFromVectors");

  }


  Matrix3RowFromVectors(out.value(), v1.value(), v2.value(), v3.value(), Var::verbosity(ws).value());

}


inline void mblock_dlos_gridUniformCircular(

            Workspace& ws,

      const Var::Numeric spacing,

      const Var::Numeric width,

      const Var::Index centre=Group::Index{0}) {

  mblock_dlos_gridUniformCircular(Var::mblock_dlos_grid(ws).value(), spacing.value(), width.value(), centre.value(), Var::verbosity(ws).value());

}


inline void mblock_dlos_gridUniformRectangular(

            Workspace& ws,

      const Var::Numeric spacing,

      const Var::Numeric za_width,

      const Var::Numeric aa_width,

      const Var::Index centre=Group::Index{0}) {

  mblock_dlos_gridUniformRectangular(Var::mblock_dlos_grid(ws).value(), spacing.value(), za_width.value(), aa_width.value(), centre.value(), Var::verbosity(ws).value());

}


inline void mc_antennaSetGaussian(

            Workspace& ws,

      const Var::Numeric za_sigma,

      const Var::Numeric aa_sigma) {

  mc_antennaSetGaussian(Var::mc_antenna(ws).value(), za_sigma.value(), aa_sigma.value(), Var::verbosity(ws).value());

}


inline void mc_antennaSetGaussianByFWHM(

            Workspace& ws,

      const Var::Numeric za_fwhm,

      const Var::Numeric aa_fwhm) {

  mc_antennaSetGaussianByFWHM(Var::mc_antenna(ws).value(), za_fwhm.value(), aa_fwhm.value(), Var::verbosity(ws).value());

}


inline void mc_antennaSetPencilBeam(

            Workspace& ws) {

  mc_antennaSetPencilBeam(Var::mc_antenna(ws).value(), Var::verbosity(ws).value());

}


inline void MCGeneral(

            Workspace& ws,

      const Var::Index l_mc_scat_order=Group::Index{11},

      const Var::Index t_interp_order=Group::Index{1}) {

  MCGeneral(ws, Var::y(ws).value(), Var::mc_iteration_count(ws).value(), Var::mc_error(ws).value(), Var::mc_points(ws).value(), Var::mc_source_domain(ws).value(), Var::mc_scat_order(ws).value(), Var::mc_antenna(ws).value(), Var::f_grid(ws).value(), Var::f_index(ws).value(), Var::sensor_pos(ws).value(), Var::sensor_los(ws).value(), Var::stokes_dim(ws).value(), Var::atmosphere_dim(ws).value(), Var::ppath_step_agenda(ws).value(), Var::ppath_lmax(ws).value(), Var::ppath_lraytrace(ws).value(), Var::iy_space_agenda(ws).value(), Var::surface_rtprop_agenda(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::refellipsoid(ws).value(), Var::z_surface(ws).value(), Var::t_field(ws).value(), Var::vmr_field(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::pnd_field(ws).value(), Var::scat_data(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::scat_data_checked(ws).value(), Var::cloudbox_checked(ws).value(), Var::iy_unit(ws).value(), Var::mc_seed(ws).value(), Var::mc_std_err(ws).value(), Var::mc_max_time(ws).value(), Var::mc_max_iter(ws).value(), Var::mc_min_iter(ws).value(), Var::mc_taustep_limit(ws).value(), l_mc_scat_order.value(), t_interp_order.value(), Var::verbosity(ws).value());

}


inline void MCRadar(

            Workspace& ws,

      const Var::Numeric ze_tref=Group::Numeric{273.15},

      const Var::Numeric k2=Group::Numeric{-1},

      const Var::Index t_interp_order=Group::Index{1}) {

  MCRadar(ws, Var::y(ws).value(), Var::mc_error(ws).value(), Var::mc_antenna(ws).value(), Var::f_grid(ws).value(), Var::f_index(ws).value(), Var::sensor_pos(ws).value(), Var::sensor_los(ws).value(), Var::stokes_dim(ws).value(), Var::atmosphere_dim(ws).value(), Var::ppath_lmax(ws).value(), Var::ppath_step_agenda(ws).value(), Var::ppath_lraytrace(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::refellipsoid(ws).value(), Var::z_surface(ws).value(), Var::t_field(ws).value(), Var::vmr_field(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::pnd_field(ws).value(), Var::scat_data(ws).value(), Var::mc_y_tx(ws).value(), Var::range_bins(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::scat_data_checked(ws).value(), Var::cloudbox_checked(ws).value(), Var::iy_unit(ws).value(), Var::mc_max_scatorder(ws).value(), Var::mc_seed(ws).value(), Var::mc_max_iter(ws).value(), ze_tref.value(), k2.value(), t_interp_order.value(), Var::verbosity(ws).value());

}


inline void MCSetSeedFromTime(

            Workspace& ws) {

  MCSetSeedFromTime(Var::mc_seed(ws).value(), Var::verbosity(ws).value());

}


inline void nlte_fieldRescalePopulationLevels(

            Workspace& ws,

      const Var::Numeric s) {

  nlte_fieldRescalePopulationLevels(Var::nlte_field(ws).value(), s.value(), Var::verbosity(ws).value());

}


inline void nlte_fieldForSingleSpeciesNonOverlappingLines(

            Workspace& ws,

      const Var::Numeric df,

      const Var::Index nz,

      const Var::Index nf,

      const Var::Index dampened,

      const Var::Numeric convergence_limit=Group::Numeric{1e-6},

      const Var::Index iteration_limit=Group::Index{20}) {

  nlte_fieldForSingleSpeciesNonOverlappingLines(ws, Var::nlte_field(ws).value(), Var::abs_species(ws).value(), Var::abs_lines_per_species(ws).value(), Var::collision_coefficients(ws).value(), Var::collision_line_identifiers(ws).value(), Var::isotopologue_ratios(ws).value(), Var::iy_main_agenda(ws).value(), Var::ppath_agenda(ws).value(), Var::iy_space_agenda(ws).value(), Var::iy_surface_agenda(ws).value(), Var::iy_cloudbox_agenda(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::water_p_eq_agenda(ws).value(), Var::vmr_field(ws).value(), Var::t_field(ws).value(), Var::z_field(ws).value(), Var::p_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::refellipsoid(ws).value(), Var::surface_props_data(ws).value(), Var::nlte_do(ws).value(), df.value(), convergence_limit.value(), nz.value(), nf.value(), dampened.value(), iteration_limit.value(), Var::verbosity(ws).value());

}


inline void collision_coefficientsFromSplitFiles(

            Workspace& ws,

      const Var::String basename=Group::String{"./"}) {

  collision_coefficientsFromSplitFiles(Var::collision_coefficients(ws).value(), Var::collision_line_identifiers(ws).value(), Var::abs_species(ws).value(), basename.value(), Var::verbosity(ws).value());

}


inline void NumericAdd(

            Workspace& ws,

            Var::Numeric out,

      const Var::Numeric in,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of NumericAdd");

  }


  NumericAdd(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void NumericFromVector(

            Workspace& ws,

            Var::Numeric out,

      const Var::Vector in,

      const Var::String op) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of NumericFromVector");

  }


  NumericFromVector(out.value(), in.value(), op.value(), Var::verbosity(ws).value());

}


inline void NumericInvScale(

            Workspace& ws,

            Var::Numeric out,

      const Var::Numeric in,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of NumericInvScale");

  }


  NumericInvScale(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void NumericScale(

            Workspace& ws,

            Var::Numeric out,

      const Var::Numeric in,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of NumericScale");

  }


  NumericScale(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void NumericSet(

            Workspace& ws,

            Var::Numeric out,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of NumericSet");

  }


  NumericSet(out.value(), value.value(), Var::verbosity(ws).value());

}


inline void QuantumIdentifierSet(

            Workspace& ws,

            Var::QuantumIdentifier out,

      const Var::String string_initializer) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceQuantumIdentifier since it is output of QuantumIdentifierSet");

  }


  QuantumIdentifierSet(out.value(), string_initializer.value(), Var::verbosity(ws).value());

}


inline void ArrayOfQuantumIdentifierSet(

            Workspace& ws,

            Var::ArrayOfQuantumIdentifier out,

      const Var::ArrayOfString string_initializers) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of ArrayOfQuantumIdentifierSet");

  }


  ArrayOfQuantumIdentifierSet(out.value(), string_initializers.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfAbsorptionLines v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfAbsorptionLines v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfAgenda v) {

  nelemGet(ws, Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField1 v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField2 v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField3 v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfIndex v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfMatrix v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfPpath v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfPropagationMatrix v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfRadiationVector v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfScatteringMetaData v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfSingleScatteringData v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfSpeciesTag v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfStokesVector v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfString v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor3 v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor6 v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfTime v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfTransmissionMatrix v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfArrayOfVector v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfCIARecord v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfGriddedField1 v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfGriddedField2 v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfGriddedField3 v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfGriddedField4 v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfIndex v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfMatrix v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfPropagationMatrix v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfRadiationVector v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfRetrievalQuantity v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfScatteringMetaData v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfSingleScatteringData v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfSparse v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfStokesVector v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfString v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfTelsemAtlas v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfTensor3 v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfTensor4 v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfTensor5 v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfTensor6 v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfTensor7 v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfTime v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfTransmissionMatrix v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfVector v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::ArrayOfXsecRecord v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nelemGet(

            Workspace& ws,

      const Var::Vector v) {

  nelemGet(Var::nelem(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void ncolsGet(

            Workspace& ws,

      const Var::Matrix v) {

  ncolsGet(Var::ncols(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void ncolsGet(

            Workspace& ws,

      const Var::Sparse v) {

  ncolsGet(Var::ncols(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void ncolsGet(

            Workspace& ws,

      const Var::Tensor3 v) {

  ncolsGet(Var::ncols(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void ncolsGet(

            Workspace& ws,

      const Var::Tensor4 v) {

  ncolsGet(Var::ncols(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void ncolsGet(

            Workspace& ws,

      const Var::Tensor5 v) {

  ncolsGet(Var::ncols(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void ncolsGet(

            Workspace& ws,

      const Var::Tensor6 v) {

  ncolsGet(Var::ncols(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void ncolsGet(

            Workspace& ws,

      const Var::Tensor7 v) {

  ncolsGet(Var::ncols(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nrowsGet(

            Workspace& ws,

      const Var::Matrix v) {

  nrowsGet(Var::nrows(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nrowsGet(

            Workspace& ws,

      const Var::Sparse v) {

  nrowsGet(Var::nrows(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nrowsGet(

            Workspace& ws,

      const Var::Tensor3 v) {

  nrowsGet(Var::nrows(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nrowsGet(

            Workspace& ws,

      const Var::Tensor4 v) {

  nrowsGet(Var::nrows(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nrowsGet(

            Workspace& ws,

      const Var::Tensor5 v) {

  nrowsGet(Var::nrows(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nrowsGet(

            Workspace& ws,

      const Var::Tensor6 v) {

  nrowsGet(Var::nrows(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nrowsGet(

            Workspace& ws,

      const Var::Tensor7 v) {

  nrowsGet(Var::nrows(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void npagesGet(

            Workspace& ws,

      const Var::Tensor3 v) {

  npagesGet(Var::npages(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void npagesGet(

            Workspace& ws,

      const Var::Tensor4 v) {

  npagesGet(Var::npages(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void npagesGet(

            Workspace& ws,

      const Var::Tensor5 v) {

  npagesGet(Var::npages(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void npagesGet(

            Workspace& ws,

      const Var::Tensor6 v) {

  npagesGet(Var::npages(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void npagesGet(

            Workspace& ws,

      const Var::Tensor7 v) {

  npagesGet(Var::npages(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nbooksGet(

            Workspace& ws,

      const Var::Tensor4 v) {

  nbooksGet(Var::nbooks(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nbooksGet(

            Workspace& ws,

      const Var::Tensor5 v) {

  nbooksGet(Var::nbooks(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nbooksGet(

            Workspace& ws,

      const Var::Tensor6 v) {

  nbooksGet(Var::nbooks(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nbooksGet(

            Workspace& ws,

      const Var::Tensor7 v) {

  nbooksGet(Var::nbooks(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nshelvesGet(

            Workspace& ws,

      const Var::Tensor5 v) {

  nshelvesGet(Var::nshelves(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nshelvesGet(

            Workspace& ws,

      const Var::Tensor6 v) {

  nshelvesGet(Var::nshelves(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nshelvesGet(

            Workspace& ws,

      const Var::Tensor7 v) {

  nshelvesGet(Var::nshelves(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nvitrinesGet(

            Workspace& ws,

      const Var::Tensor6 v) {

  nvitrinesGet(Var::nvitrines(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nvitrinesGet(

            Workspace& ws,

      const Var::Tensor7 v) {

  nvitrinesGet(Var::nvitrines(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nlibrariesGet(

            Workspace& ws,

      const Var::Tensor7 v) {

  nlibrariesGet(Var::nlibraries(ws).value(), v.value(), Var::verbosity(ws).value());

}


inline void nlte_sourceFromTemperatureAndSrcCoefPerSpecies(

            Workspace& ws) {

  nlte_sourceFromTemperatureAndSrcCoefPerSpecies(Var::nlte_source(ws).value(), Var::dnlte_dx_source(ws).value(), Var::nlte_dsource_dx(ws).value(), Var::src_coef_per_species(ws).value(), Var::dsrc_coef_dx(ws).value(), Var::jacobian_quantities(ws).value(), Var::f_grid(ws).value(), Var::rtp_temperature(ws).value(), Var::verbosity(ws).value());

}


inline void nlteOff(

            Workspace& ws) {

  nlteOff(Var::nlte_do(ws).value(), Var::nlte_field(ws).value(), Var::nlte_level_identifiers(ws).value(), Var::verbosity(ws).value());

}


inline void nlteSetByQuantumIdentifiers(

            Workspace& ws) {

  nlteSetByQuantumIdentifiers(Var::nlte_do(ws).value(), Var::abs_lines_per_species(ws).value(), Var::nlte_field(ws).value(), Var::verbosity(ws).value());

}


inline void nlte_fieldFromRaw(

            Workspace& ws,

      const Var::Tensor4 data) {

  nlte_fieldFromRaw(Var::nlte_field(ws).value(), Var::nlte_level_identifiers(ws).value(), Var::nlte_vibrational_energies(ws).value(), data.value(), Var::verbosity(ws).value());

}


inline void nlte_fieldSetLteExternalPartitionFunction(

            Workspace& ws) {

  nlte_fieldSetLteExternalPartitionFunction(Var::nlte_do(ws).value(), Var::nlte_field(ws).value(), Var::abs_lines_per_species(ws).value(), Var::nlte_level_identifiers(ws).value(), Var::partition_functions(ws).value(), Var::t_field(ws).value(), Var::verbosity(ws).value());

}


inline void ArrayOfQuantumIdentifierFromLines(

            Workspace& ws,

            Var::ArrayOfQuantumIdentifier out,

      const Var::Index global=Group::Index{1}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of ArrayOfQuantumIdentifierFromLines");

  }


  ArrayOfQuantumIdentifierFromLines(out.value(), Var::abs_lines_per_species(ws).value(), global.value(), Var::verbosity(ws).value());

}


inline void nlte_fieldSetLteInternalPartitionFunction(

            Workspace& ws) {

  nlte_fieldSetLteInternalPartitionFunction(Var::nlte_do(ws).value(), Var::nlte_field(ws).value(), Var::abs_lines_per_species(ws).value(), Var::nlte_level_identifiers(ws).value(), Var::t_field(ws).value(), Var::verbosity(ws).value());

}


inline void timeNow(

            Workspace& ws) {

  timeNow(Var::time(ws).value(), Var::verbosity(ws).value());

}


inline void timeOffset(

            Workspace& ws,

      const Var::Numeric offset) {

  timeOffset(Var::time(ws).value(), offset.value(), Var::verbosity(ws).value());

}


inline void OEM(

            Workspace& ws,

      const Var::String method,

      const Var::Numeric max_start_cost=Group::Numeric{std::numeric_limits<Numeric>::infinity()},

      const Var::Vector x_norm=Group::Vector{},

      const Var::Index max_iter=Group::Index{10},

      const Var::Numeric stop_dx=Group::Numeric{0.01},

      const Var::Vector lm_ga_settings=Group::Vector{},

      const Var::Index clear_matrices=Group::Index{0},

      const Var::Index display_progress=Group::Index{0}) {

  OEM(ws, Var::x(ws).value(), Var::yf(ws).value(), Var::jacobian(ws).value(), Var::dxdy(ws).value(), Var::oem_diagnostics(ws).value(), Var::lm_ga_history(ws).value(), Var::oem_errors(ws).value(), Var::xa(ws).value(), Var::covmat_sx(ws).value(), Var::y(ws).value(), Var::covmat_se(ws).value(), Var::jacobian_quantities(ws).value(), Var::inversion_iterate_agenda(ws).value(), method.value(), max_start_cost.value(), x_norm.value(), max_iter.value(), stop_dx.value(), lm_ga_settings.value(), clear_matrices.value(), display_progress.value(), Var::verbosity(ws).value());

}


inline void avkCalc(

            Workspace& ws) {

  avkCalc(Var::avk(ws).value(), Var::dxdy(ws).value(), Var::jacobian(ws).value(), Var::verbosity(ws).value());

}


inline void covmat_soCalc(

            Workspace& ws) {

  covmat_soCalc(Var::covmat_so(ws).value(), Var::dxdy(ws).value(), Var::covmat_se(ws).value(), Var::verbosity(ws).value());

}


inline void covmat_ssCalc(

            Workspace& ws) {

  covmat_ssCalc(Var::covmat_ss(ws).value(), Var::avk(ws).value(), Var::covmat_sx(ws).value(), Var::verbosity(ws).value());

}


inline void opt_prop_bulkCalc(

            Workspace& ws) {

  opt_prop_bulkCalc(Var::ext_mat(ws).value(), Var::abs_vec(ws).value(), Var::ext_mat_spt(ws).value(), Var::abs_vec_spt(ws).value(), Var::pnd_field(ws).value(), Var::scat_p_index(ws).value(), Var::scat_lat_index(ws).value(), Var::scat_lon_index(ws).value(), Var::verbosity(ws).value());

}


inline void opt_prop_sptFromData(

            Workspace& ws) {

  opt_prop_sptFromData(Var::ext_mat_spt(ws).value(), Var::abs_vec_spt(ws).value(), Var::scat_data(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::za_index(ws).value(), Var::aa_index(ws).value(), Var::f_index(ws).value(), Var::f_grid(ws).value(), Var::rtp_temperature(ws).value(), Var::pnd_field(ws).value(), Var::scat_p_index(ws).value(), Var::scat_lat_index(ws).value(), Var::scat_lon_index(ws).value(), Var::verbosity(ws).value());

}


inline void opt_prop_sptFromScat_data(

            Workspace& ws) {

  opt_prop_sptFromScat_data(Var::ext_mat_spt(ws).value(), Var::abs_vec_spt(ws).value(), Var::scat_data(ws).value(), Var::scat_data_checked(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::za_index(ws).value(), Var::aa_index(ws).value(), Var::f_index(ws).value(), Var::rtp_temperature(ws).value(), Var::pnd_field(ws).value(), Var::scat_p_index(ws).value(), Var::scat_lat_index(ws).value(), Var::scat_lon_index(ws).value(), Var::verbosity(ws).value());

}


inline void opt_prop_sptFromMonoData(

            Workspace& ws) {

  opt_prop_sptFromMonoData(Var::ext_mat_spt(ws).value(), Var::abs_vec_spt(ws).value(), Var::scat_data_mono(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::za_index(ws).value(), Var::aa_index(ws).value(), Var::rtp_temperature(ws).value(), Var::pnd_field(ws).value(), Var::scat_p_index(ws).value(), Var::scat_lat_index(ws).value(), Var::scat_lon_index(ws).value(), Var::verbosity(ws).value());

}


inline void output_file_formatSetAscii(

            Workspace& ws) {

  output_file_formatSetAscii(Var::output_file_format(ws).value(), Var::verbosity(ws).value());

}


inline void output_file_formatSetBinary(

            Workspace& ws) {

  output_file_formatSetBinary(Var::output_file_format(ws).value(), Var::verbosity(ws).value());

}


inline void output_file_formatSetZippedAscii(

            Workspace& ws) {

  output_file_formatSetZippedAscii(Var::output_file_format(ws).value(), Var::verbosity(ws).value());

}


inline void particle_bulkprop_fieldClip(

            Workspace& ws,

      const Var::String bulkprop_name,

      const Var::Numeric limit_low=Group::Numeric{-std::numeric_limits<Numeric>::infinity()},

      const Var::Numeric limit_high=Group::Numeric{std::numeric_limits<Numeric>::infinity()}) {

  particle_bulkprop_fieldClip(Var::particle_bulkprop_field(ws).value(), Var::particle_bulkprop_names(ws).value(), bulkprop_name.value(), limit_low.value(), limit_high.value(), Var::verbosity(ws).value());

}


inline void particle_bulkprop_fieldPerturb(

            Workspace& ws,

      const Var::String particle_type,

      const Var::Vector p_ret_grid,

      const Var::Vector lat_ret_grid,

      const Var::Vector lon_ret_grid,

      const Var::Index pert_index,

      const Var::Numeric pert_size,

      const Var::String pert_mode=Group::String{"absolute"}) {

  particle_bulkprop_fieldPerturb(Var::particle_bulkprop_field(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::particle_bulkprop_names(ws).value(), particle_type.value(), p_ret_grid.value(), lat_ret_grid.value(), lon_ret_grid.value(), pert_index.value(), pert_size.value(), pert_mode.value(), Var::verbosity(ws).value());

}


inline void particle_bulkprop_fieldPerturbAtmGrids(

            Workspace& ws,

      const Var::String particle_type,

      const Var::Index pert_index,

      const Var::Numeric pert_size,

      const Var::String pert_mode=Group::String{"absolute"}) {

  particle_bulkprop_fieldPerturbAtmGrids(Var::particle_bulkprop_field(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::particle_bulkprop_names(ws).value(), particle_type.value(), pert_index.value(), pert_size.value(), pert_mode.value(), Var::verbosity(ws).value());

}


inline void particle_massesFromMetaDataSingleCategory(

            Workspace& ws) {

  particle_massesFromMetaDataSingleCategory(Var::particle_masses(ws).value(), Var::scat_meta(ws).value(), Var::verbosity(ws).value());

}


inline void particle_massesFromMetaData(

            Workspace& ws) {

  particle_massesFromMetaData(Var::particle_masses(ws).value(), Var::scat_meta(ws).value(), Var::verbosity(ws).value());

}


inline void partition_functionsInitFromBuiltin(

            Workspace& ws) {

  partition_functionsInitFromBuiltin(Var::partition_functions(ws).value(), Var::verbosity(ws).value());

}


inline void pha_matCalc(

            Workspace& ws) {

  pha_matCalc(Var::pha_mat(ws).value(), Var::pha_mat_spt(ws).value(), Var::pnd_field(ws).value(), Var::atmosphere_dim(ws).value(), Var::scat_p_index(ws).value(), Var::scat_lat_index(ws).value(), Var::scat_lon_index(ws).value(), Var::verbosity(ws).value());

}


inline void pha_mat_sptFromData(

            Workspace& ws) {

  pha_mat_sptFromData(Var::pha_mat_spt(ws).value(), Var::scat_data(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::za_index(ws).value(), Var::aa_index(ws).value(), Var::f_index(ws).value(), Var::f_grid(ws).value(), Var::rtp_temperature(ws).value(), Var::pnd_field(ws).value(), Var::scat_p_index(ws).value(), Var::scat_lat_index(ws).value(), Var::scat_lon_index(ws).value(), Var::verbosity(ws).value());

}


inline void pha_mat_sptFromDataDOITOpt(

            Workspace& ws) {

  pha_mat_sptFromDataDOITOpt(Var::pha_mat_spt(ws).value(), Var::pha_mat_sptDOITOpt(ws).value(), Var::scat_data_mono(ws).value(), Var::doit_za_grid_size(ws).value(), Var::aa_grid(ws).value(), Var::za_index(ws).value(), Var::aa_index(ws).value(), Var::rtp_temperature(ws).value(), Var::pnd_field(ws).value(), Var::scat_p_index(ws).value(), Var::scat_lat_index(ws).value(), Var::scat_lon_index(ws).value(), Var::verbosity(ws).value());

}


inline void pha_mat_sptFromMonoData(

            Workspace& ws) {

  pha_mat_sptFromMonoData(Var::pha_mat_spt(ws).value(), Var::scat_data_mono(ws).value(), Var::doit_za_grid_size(ws).value(), Var::aa_grid(ws).value(), Var::za_index(ws).value(), Var::aa_index(ws).value(), Var::rtp_temperature(ws).value(), Var::pnd_field(ws).value(), Var::scat_p_index(ws).value(), Var::scat_lat_index(ws).value(), Var::scat_lon_index(ws).value(), Var::verbosity(ws).value());

}


inline void pha_mat_sptFromScat_data(

            Workspace& ws) {

  pha_mat_sptFromScat_data(Var::pha_mat_spt(ws).value(), Var::scat_data(ws).value(), Var::scat_data_checked(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::za_index(ws).value(), Var::aa_index(ws).value(), Var::f_index(ws).value(), Var::rtp_temperature(ws).value(), Var::pnd_field(ws).value(), Var::scat_p_index(ws).value(), Var::scat_lat_index(ws).value(), Var::scat_lon_index(ws).value(), Var::verbosity(ws).value());

}


inline void pndFromPsd(

            Workspace& ws,

      const Var::Index scat_index,

      const Var::Index quad_order=Group::Index{1},

      const Var::Numeric threshold_se_ext=Group::Numeric{0.02},

      const Var::Numeric threshold_ss_ext=Group::Numeric{1e-8},

      const Var::Numeric threshold_se_pnd=Group::Numeric{0.02}) {

  pndFromPsd(Var::pnd_data(ws).value(), Var::dpnd_data_dx(ws).value(), Var::pnd_size_grid(ws).value(), Var::psd_data(ws).value(), Var::psd_size_grid(ws).value(), Var::dpsd_data_dx(ws).value(), Var::scat_data(ws).value(), Var::f_grid(ws).value(), Var::scat_data_checked(ws).value(), quad_order.value(), scat_index.value(), threshold_se_ext.value(), threshold_ss_ext.value(), threshold_se_pnd.value(), Var::verbosity(ws).value());

}


inline void pndFromPsdBasic(

            Workspace& ws,

      const Var::Index quad_order=Group::Index{1}) {

  pndFromPsdBasic(Var::pnd_data(ws).value(), Var::dpnd_data_dx(ws).value(), Var::pnd_size_grid(ws).value(), Var::psd_data(ws).value(), Var::psd_size_grid(ws).value(), Var::dpsd_data_dx(ws).value(), quad_order.value(), Var::verbosity(ws).value());

}


inline void pnd_fieldCalcFromParticleBulkProps(

            Workspace& ws) {

  pnd_fieldCalcFromParticleBulkProps(ws, Var::pnd_field(ws).value(), Var::dpnd_field_dx(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::t_field(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::scat_species(ws).value(), Var::scat_data(ws).value(), Var::scat_meta(ws).value(), Var::particle_bulkprop_field(ws).value(), Var::particle_bulkprop_names(ws).value(), Var::pnd_agenda_array(ws).value(), Var::pnd_agenda_array_input_names(ws).value(), Var::jacobian_do(ws).value(), Var::jacobian_quantities(ws).value(), Var::verbosity(ws).value());

}


inline void pnd_fieldCalcFrompnd_field_raw(

            Workspace& ws,

      const Var::Index zeropadding=Group::Index{0}) {

  pnd_fieldCalcFrompnd_field_raw(Var::pnd_field(ws).value(), Var::dpnd_field_dx(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::pnd_field_raw(ws).value(), Var::atmosphere_dim(ws).value(), Var::cloudbox_limits(ws).value(), Var::jacobian_quantities(ws).value(), zeropadding.value(), Var::verbosity(ws).value());

}


inline void pnd_fieldExpand1D(

            Workspace& ws,

      const Var::Index nzero=Group::Index{1}) {

  pnd_fieldExpand1D(Var::pnd_field(ws).value(), Var::atmosphere_dim(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), nzero.value(), Var::verbosity(ws).value());

}


inline void pnd_fieldZero(

            Workspace& ws) {

  pnd_fieldZero(Var::pnd_field(ws).value(), Var::dpnd_field_dx(ws).value(), Var::scat_data(ws).value(), Var::atmosphere_dim(ws).value(), Var::f_grid(ws).value(), Var::cloudbox_limits(ws).value(), Var::jacobian_quantities(ws).value(), Var::verbosity(ws).value());

}


inline void ppath_fieldFromDownUpLimbGeoms(

            Workspace& ws,

      const Var::Index nz=Group::Index{3}) {

  ppath_fieldFromDownUpLimbGeoms(ws, Var::ppath_field(ws).value(), Var::ppath_agenda(ws).value(), Var::ppath_lmax(ws).value(), Var::ppath_lraytrace(ws).value(), Var::atmgeom_checked(ws).value(), Var::z_field(ws).value(), Var::f_grid(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_checked(ws).value(), Var::ppath_inside_cloudbox_do(ws).value(), Var::rte_pos(ws).value(), Var::rte_los(ws).value(), Var::rte_pos2(ws).value(), Var::refellipsoid(ws).value(), Var::atmosphere_dim(ws).value(), nz.value(), Var::verbosity(ws).value());

}


inline void ppathCalc(

            Workspace& ws) {

  ppathCalc(ws, Var::ppath(ws).value(), Var::ppath_agenda(ws).value(), Var::ppath_lmax(ws).value(), Var::ppath_lraytrace(ws).value(), Var::atmgeom_checked(ws).value(), Var::f_grid(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_checked(ws).value(), Var::ppath_inside_cloudbox_do(ws).value(), Var::rte_pos(ws).value(), Var::rte_los(ws).value(), Var::rte_pos2(ws).value(), Var::verbosity(ws).value());

}


inline void ppath_fieldCalc(

            Workspace& ws) {

  ppath_fieldCalc(ws, Var::ppath_field(ws).value(), Var::ppath_agenda(ws).value(), Var::ppath_lmax(ws).value(), Var::ppath_lraytrace(ws).value(), Var::atmgeom_checked(ws).value(), Var::f_grid(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_checked(ws).value(), Var::ppath_inside_cloudbox_do(ws).value(), Var::sensor_pos(ws).value(), Var::sensor_los(ws).value(), Var::rte_pos2(ws).value(), Var::verbosity(ws).value());

}


inline void ppathCalcFromAltitude(

            Workspace& ws,

      const Var::Numeric altitude,

      const Var::Numeric accuracy=Group::Numeric{0.5}) {

  ppathCalcFromAltitude(ws, Var::ppath(ws).value(), Var::ppath_agenda(ws).value(), Var::ppath_lmax(ws).value(), Var::ppath_lraytrace(ws).value(), Var::atmgeom_checked(ws).value(), Var::f_grid(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_checked(ws).value(), Var::ppath_inside_cloudbox_do(ws).value(), Var::rte_pos(ws).value(), Var::rte_los(ws).value(), Var::rte_pos2(ws).value(), altitude.value(), accuracy.value(), Var::verbosity(ws).value());

}


inline void ppathFromRtePos2(

            Workspace& ws,

      const Var::Numeric za_accuracy=Group::Numeric{2e-5},

      const Var::Numeric pplrt_factor=Group::Numeric{5},

      const Var::Numeric pplrt_lowest=Group::Numeric{0.5}) {

  ppathFromRtePos2(ws, Var::ppath(ws).value(), Var::rte_los(ws).value(), Var::ppath_lraytrace(ws).value(), Var::ppath_step_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::f_grid(ws).value(), Var::refellipsoid(ws).value(), Var::z_surface(ws).value(), Var::rte_pos(ws).value(), Var::rte_pos2(ws).value(), Var::ppath_lmax(ws).value(), za_accuracy.value(), pplrt_factor.value(), pplrt_lowest.value(), Var::verbosity(ws).value());

}


inline void ppathPlaneParallel(

            Workspace& ws) {

  ppathPlaneParallel(Var::ppath(ws).value(), Var::atmosphere_dim(ws).value(), Var::z_field(ws).value(), Var::z_surface(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::ppath_inside_cloudbox_do(ws).value(), Var::rte_pos(ws).value(), Var::rte_los(ws).value(), Var::ppath_lmax(ws).value(), Var::verbosity(ws).value());

}


inline void ppathStepByStep(

            Workspace& ws) {

  ppathStepByStep(ws, Var::ppath(ws).value(), Var::ppath_step_agenda(ws).value(), Var::ppath_inside_cloudbox_do(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::f_grid(ws).value(), Var::refellipsoid(ws).value(), Var::z_surface(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::rte_pos(ws).value(), Var::rte_los(ws).value(), Var::ppath_lmax(ws).value(), Var::ppath_lraytrace(ws).value(), Var::verbosity(ws).value());

}


inline void ppathWriteXMLPartial(

            Workspace& ws,

      const Var::String filename=Group::String{""},

      const Var::Index file_index=Group::Index{-1}) {

  ppathWriteXMLPartial(Var::output_file_format(ws).value(), Var::ppath(ws).value(), filename.value(), file_index.value(), Var::verbosity(ws).value());

}


inline void ppath_stepGeometric(

            Workspace& ws) {

  ppath_stepGeometric(Var::ppath_step(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::refellipsoid(ws).value(), Var::z_surface(ws).value(), Var::ppath_lmax(ws).value(), Var::verbosity(ws).value());

}


inline void ppath_stepRefractionBasic(

            Workspace& ws) {

  ppath_stepRefractionBasic(ws, Var::ppath_step(ws).value(), Var::refr_index_air_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field(ws).value(), Var::t_field(ws).value(), Var::vmr_field(ws).value(), Var::refellipsoid(ws).value(), Var::z_surface(ws).value(), Var::f_grid(ws).value(), Var::ppath_lmax(ws).value(), Var::ppath_lraytrace(ws).value(), Var::verbosity(ws).value());

}


inline void ppvar_optical_depthFromPpvar_trans_cumulat(

            Workspace& ws) {

  ppvar_optical_depthFromPpvar_trans_cumulat(Var::ppvar_optical_depth(ws).value(), Var::ppvar_trans_cumulat(ws).value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::AbsorptionLines in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Agenda in,

      const Var::Index level=Group::Index{1}) {

  Print(ws, in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfAbsorptionLines in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfAbsorptionLines in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfAgenda in,

      const Var::Index level=Group::Index{1}) {

  Print(ws, in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField1 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField2 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField3 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfIndex in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfMatrix in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfPpath in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfPropagationMatrix in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfRadiationVector in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfScatteringMetaData in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfSingleScatteringData in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfSpeciesTag in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfStokesVector in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfString in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor3 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor6 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfTime in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfTransmissionMatrix in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfArrayOfVector in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfCIARecord in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfGriddedField1 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfGriddedField2 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfGriddedField3 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfGriddedField4 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfIndex in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfMatrix in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfPropagationMatrix in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfRadiationVector in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfRetrievalQuantity in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfScatteringMetaData in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfSingleScatteringData in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfSparse in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfStokesVector in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfString in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfTelsemAtlas in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfTensor3 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfTensor4 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfTensor5 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfTensor6 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfTensor7 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfTime in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfTransmissionMatrix in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfVector in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ArrayOfXsecRecord in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::CIARecord in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::CovarianceMatrix in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::EnergyLevelMap in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::GasAbsLookup in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::GridPos in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::GriddedField1 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::GriddedField2 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::GriddedField3 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::GriddedField4 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::GriddedField5 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::GriddedField6 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::HitranRelaxationMatrixData in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Index in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::MCAntenna in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Matrix in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Numeric in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Ppath in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::PropagationMatrix in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::QuantumIdentifier in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::RadiationVector in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Rational in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::ScatteringMetaData in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::SingleScatteringData in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Sparse in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::SpeciesAuxData in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::StokesVector in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::String in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::TelsemAtlas in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Tensor3 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Tensor4 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Tensor5 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Tensor6 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Tensor7 in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Timer in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Time in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::TessemNN in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::TransmissionMatrix in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Vector in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void Print(

            Workspace& ws,

      const Var::Verbosity in,

      const Var::Index level=Group::Index{1}) {

  Print(in.value(), level.value(), Var::verbosity(ws).value());

}


inline void PrintPhysicalConstants(

            Workspace& ws) {

  PrintPhysicalConstants(Var::verbosity(ws).value());

}


inline void PrintWorkspace(

            Workspace& ws,

      const Var::Index only_allocated=Group::Index{1},

      const Var::Index level=Group::Index{1}) {

  PrintWorkspace(ws, only_allocated.value(), level.value(), Var::verbosity(ws).value());

}


inline void ZFromPSimple(

            Workspace& ws,

            Var::Vector z_grid,

      const Var::Vector p_grid) {

  if (z_grid.islast()) {

    throw std::runtime_error("z_grid needs to be a defined WorkspaceVector since it is output of ZFromPSimple");

  }


  ZFromPSimple(z_grid.value(), p_grid.value(), Var::verbosity(ws).value());

}


inline void PFromZSimple(

            Workspace& ws,

            Var::Vector p_grid,

      const Var::Vector z_grid) {

  if (p_grid.islast()) {

    throw std::runtime_error("p_grid needs to be a defined WorkspaceVector since it is output of PFromZSimple");

  }


  PFromZSimple(p_grid.value(), z_grid.value(), Var::verbosity(ws).value());

}


inline void propmat_clearskyAddFaraday(

            Workspace& ws) {

  propmat_clearskyAddFaraday(Var::propmat_clearsky(ws).value(), Var::dpropmat_clearsky_dx(ws).value(), Var::stokes_dim(ws).value(), Var::atmosphere_dim(ws).value(), Var::f_grid(ws).value(), Var::abs_species(ws).value(), Var::jacobian_quantities(ws).value(), Var::rtp_vmr(ws).value(), Var::rtp_los(ws).value(), Var::rtp_mag(ws).value(), Var::verbosity(ws).value());

}


inline void propmat_clearskyAddFromAbsCoefPerSpecies(

            Workspace& ws) {

  propmat_clearskyAddFromAbsCoefPerSpecies(Var::propmat_clearsky(ws).value(), Var::dpropmat_clearsky_dx(ws).value(), Var::abs_coef_per_species(ws).value(), Var::dabs_coef_dx(ws).value(), Var::verbosity(ws).value());

}


inline void propmat_clearskyAddFromLookup(

            Workspace& ws,

      const Var::Numeric extpolfac=Group::Numeric{0.5}) {

  propmat_clearskyAddFromLookup(Var::propmat_clearsky(ws).value(), Var::dpropmat_clearsky_dx(ws).value(), Var::abs_lookup(ws).value(), Var::abs_lookup_is_adapted(ws).value(), Var::abs_p_interp_order(ws).value(), Var::abs_t_interp_order(ws).value(), Var::abs_nls_interp_order(ws).value(), Var::abs_f_interp_order(ws).value(), Var::f_grid(ws).value(), Var::rtp_pressure(ws).value(), Var::rtp_temperature(ws).value(), Var::rtp_vmr(ws).value(), Var::jacobian_quantities(ws).value(), extpolfac.value(), Var::verbosity(ws).value());

}


inline void propmat_clearskyAddHitranLineMixingLines(

            Workspace& ws) {

  propmat_clearskyAddHitranLineMixingLines(Var::propmat_clearsky(ws).value(), Var::abs_hitran_relmat_data(ws).value(), Var::abs_lines_per_species(ws).value(), Var::f_grid(ws).value(), Var::abs_species(ws).value(), Var::jacobian_quantities(ws).value(), Var::partition_functions(ws).value(), Var::rtp_pressure(ws).value(), Var::rtp_temperature(ws).value(), Var::rtp_vmr(ws).value(), Var::verbosity(ws).value());

}


inline void propmat_clearskyAddOnTheFly(

            Workspace& ws) {

  propmat_clearskyAddOnTheFly(ws, Var::propmat_clearsky(ws).value(), Var::nlte_source(ws).value(), Var::dpropmat_clearsky_dx(ws).value(), Var::dnlte_dx_source(ws).value(), Var::nlte_dsource_dx(ws).value(), Var::f_grid(ws).value(), Var::abs_species(ws).value(), Var::jacobian_quantities(ws).value(), Var::rtp_pressure(ws).value(), Var::rtp_temperature(ws).value(), Var::rtp_nlte(ws).value(), Var::rtp_vmr(ws).value(), Var::abs_xsec_agenda(ws).value(), Var::verbosity(ws).value());

}


inline void propmat_clearskyAddParticles(

            Workspace& ws,

      const Var::Index use_abs_as_ext=Group::Index{1}) {

  propmat_clearskyAddParticles(Var::propmat_clearsky(ws).value(), Var::dpropmat_clearsky_dx(ws).value(), Var::stokes_dim(ws).value(), Var::atmosphere_dim(ws).value(), Var::f_grid(ws).value(), Var::abs_species(ws).value(), Var::jacobian_quantities(ws).value(), Var::rtp_vmr(ws).value(), Var::rtp_los(ws).value(), Var::rtp_temperature(ws).value(), Var::scat_data(ws).value(), Var::scat_data_checked(ws).value(), use_abs_as_ext.value(), Var::verbosity(ws).value());

}


inline void propmat_clearskyAddZeeman(

            Workspace& ws,

      const Var::Index manual_zeeman_tag=Group::Index{0},

      const Var::Numeric manual_zeeman_magnetic_field_strength=Group::Numeric{1.0},

      const Var::Numeric manual_zeeman_theta=Group::Numeric{0.0},

      const Var::Numeric manual_zeeman_eta=Group::Numeric{0.0}) {

  propmat_clearskyAddZeeman(Var::propmat_clearsky(ws).value(), Var::nlte_source(ws).value(), Var::dpropmat_clearsky_dx(ws).value(), Var::dnlte_dx_source(ws).value(), Var::nlte_dsource_dx(ws).value(), Var::abs_lines_per_species(ws).value(), Var::f_grid(ws).value(), Var::abs_species(ws).value(), Var::jacobian_quantities(ws).value(), Var::isotopologue_ratios(ws).value(), Var::partition_functions(ws).value(), Var::rtp_pressure(ws).value(), Var::rtp_temperature(ws).value(), Var::rtp_nlte(ws).value(), Var::rtp_vmr(ws).value(), Var::rtp_mag(ws).value(), Var::rtp_los(ws).value(), Var::atmosphere_dim(ws).value(), Var::lbl_checked(ws).value(), manual_zeeman_tag.value(), manual_zeeman_magnetic_field_strength.value(), manual_zeeman_theta.value(), manual_zeeman_eta.value(), Var::verbosity(ws).value());

}


inline void propmat_clearskyInit(

            Workspace& ws) {

  propmat_clearskyInit(Var::propmat_clearsky(ws).value(), Var::nlte_source(ws).value(), Var::dpropmat_clearsky_dx(ws).value(), Var::dnlte_dx_source(ws).value(), Var::nlte_dsource_dx(ws).value(), Var::abs_species(ws).value(), Var::jacobian_quantities(ws).value(), Var::f_grid(ws).value(), Var::stokes_dim(ws).value(), Var::propmat_clearsky_agenda_checked(ws).value(), Var::nlte_do(ws).value(), Var::verbosity(ws).value());

}


inline void propmat_clearskyZero(

            Workspace& ws) {

  propmat_clearskyZero(Var::propmat_clearsky(ws).value(), Var::f_grid(ws).value(), Var::stokes_dim(ws).value(), Var::verbosity(ws).value());

}


inline void propmat_clearskyForceNegativeToZero(

            Workspace& ws) {

  propmat_clearskyForceNegativeToZero(Var::propmat_clearsky(ws).value(), Var::verbosity(ws).value());

}


inline void propmat_clearsky_agenda_checkedCalc(

            Workspace& ws) {

  propmat_clearsky_agenda_checkedCalc(ws, Var::propmat_clearsky_agenda_checked(ws).value(), Var::abs_species(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::verbosity(ws).value());

}


inline void propmat_clearsky_fieldCalc(

            Workspace& ws,

      const Var::Vector doppler=Group::Vector{},

      const Var::Vector los=Group::Vector{}) {

  propmat_clearsky_fieldCalc(ws, Var::propmat_clearsky_field(ws).value(), Var::nlte_source_field(ws).value(), Var::atmfields_checked(ws).value(), Var::f_grid(ws).value(), Var::stokes_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::t_field(ws).value(), Var::vmr_field(ws).value(), Var::nlte_field(ws).value(), Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::propmat_clearsky_agenda(ws).value(), doppler.value(), los.value(), Var::verbosity(ws).value());

}


inline void psdAbelBoutle12(

            Workspace& ws,

      const Var::Numeric t_min=Group::Numeric{273},

      const Var::Numeric t_max=Group::Numeric{373},

      const Var::Index picky=Group::Index{0}) {

  psdAbelBoutle12(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), Var::scat_species_a(ws).value(), Var::scat_species_b(ws).value(), t_min.value(), t_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdDelanoeEtAl14(

            Workspace& ws,

      const Var::Numeric t_min,

      const Var::Numeric t_max,

      const Var::Numeric iwc=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric n0Star=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric Dm=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric rho=Group::Numeric{917.6},

      const Var::Numeric alpha=Group::Numeric{-0.237},

      const Var::Numeric beta=Group::Numeric{1.839},

      const Var::Numeric dm_min=Group::Numeric{-1.0},

      const Var::Index picky=Group::Index{0}) {

  psdDelanoeEtAl14(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), iwc.value(), n0Star.value(), Dm.value(), rho.value(), alpha.value(), beta.value(), t_min.value(), t_max.value(), dm_min.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdFieldEtAl07(

            Workspace& ws,

      const Var::String regime,

      const Var::Numeric t_min=Group::Numeric{0},

      const Var::Numeric t_max=Group::Numeric{290.},

      const Var::Numeric t_min_psd=Group::Numeric{200.},

      const Var::Numeric t_max_psd=Group::Numeric{273.15},

      const Var::Numeric beta_min=Group::Numeric{1.01},

      const Var::Numeric beta_max=Group::Numeric{4},

      const Var::Index picky=Group::Index{0}) {

  psdFieldEtAl07(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), Var::scat_species_a(ws).value(), Var::scat_species_b(ws).value(), regime.value(), t_min.value(), t_max.value(), t_min_psd.value(), t_max_psd.value(), beta_min.value(), beta_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdFieldEtAl19(

            Workspace& ws,

      const Var::Numeric t_min,

      const Var::Numeric t_max,

      const Var::Index picky=Group::Index{0}) {

  psdFieldEtAl19(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), Var::scat_species_a(ws).value(), Var::scat_species_b(ws).value(), t_min.value(), t_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdMcFarquaharHeymsfield97(

            Workspace& ws,

      const Var::Numeric t_min=Group::Numeric{0},

      const Var::Numeric t_max=Group::Numeric{280.},

      const Var::Numeric t_min_psd=Group::Numeric{180},

      const Var::Numeric t_max_psd=Group::Numeric{273.15},

      const Var::Index picky=Group::Index{0},

      const Var::Index noisy=Group::Index{0}) {

  psdMcFarquaharHeymsfield97(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), Var::scat_species_a(ws).value(), Var::scat_species_b(ws).value(), t_min.value(), t_max.value(), t_min_psd.value(), t_max_psd.value(), picky.value(), noisy.value(), Var::verbosity(ws).value());

}


inline void psdMilbrandtYau05(

            Workspace& ws,

      const Var::String hydrometeor_type,

      const Var::Numeric t_min=Group::Numeric{0},

      const Var::Numeric t_max=Group::Numeric{999},

      const Var::Index picky=Group::Index{0}) {

  psdMilbrandtYau05(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), hydrometeor_type.value(), t_min.value(), t_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdModifiedGamma(

            Workspace& ws,

      const Var::Numeric t_min,

      const Var::Numeric t_max,

      const Var::Numeric n0=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric mu=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric la=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric ga=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Index picky=Group::Index{0}) {

  psdModifiedGamma(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), n0.value(), mu.value(), la.value(), ga.value(), t_min.value(), t_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdModifiedGammaMass(

            Workspace& ws,

      const Var::Numeric t_min,

      const Var::Numeric t_max,

      const Var::Numeric n0=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric mu=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric la=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric ga=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Index picky=Group::Index{0}) {

  psdModifiedGammaMass(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), Var::scat_species_a(ws).value(), Var::scat_species_b(ws).value(), n0.value(), mu.value(), la.value(), ga.value(), t_min.value(), t_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdModifiedGammaMassNtot(

            Workspace& ws,

      const Var::Numeric t_min,

      const Var::Numeric t_max,

      const Var::Numeric n0=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric mu=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric la=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric ga=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Index picky=Group::Index{0}) {

  psdModifiedGammaMassNtot(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), Var::scat_species_a(ws).value(), Var::scat_species_b(ws).value(), n0.value(), mu.value(), la.value(), ga.value(), t_min.value(), t_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdModifiedGammaMassMeanParticleMass(

            Workspace& ws,

      const Var::Numeric t_min,

      const Var::Numeric t_max,

      const Var::Numeric n0=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric mu=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric la=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric ga=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Index picky=Group::Index{0}) {

  psdModifiedGammaMassMeanParticleMass(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), Var::scat_species_a(ws).value(), Var::scat_species_b(ws).value(), n0.value(), mu.value(), la.value(), ga.value(), t_min.value(), t_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdModifiedGammaMassSingleMoment(

            Workspace& ws,

      const Var::Numeric n_alpha,

      const Var::Numeric n_b,

      const Var::Numeric mu,

      const Var::Numeric gamma,

      const Var::Numeric t_min,

      const Var::Numeric t_max,

      const Var::Index picky=Group::Index{0}) {

  psdModifiedGammaMassSingleMoment(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), Var::scat_species_a(ws).value(), Var::scat_species_b(ws).value(), n_alpha.value(), n_b.value(), mu.value(), gamma.value(), t_min.value(), t_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdModifiedGammaMassXmean(

            Workspace& ws,

      const Var::Numeric t_min,

      const Var::Numeric t_max,

      const Var::Numeric n0=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric mu=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric la=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric ga=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Index picky=Group::Index{0}) {

  psdModifiedGammaMassXmean(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), Var::scat_species_a(ws).value(), Var::scat_species_b(ws).value(), n0.value(), mu.value(), la.value(), ga.value(), t_min.value(), t_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdModifiedGammaMassXmedian(

            Workspace& ws,

      const Var::Numeric t_min,

      const Var::Numeric t_max,

      const Var::Numeric n0=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric mu=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric la=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Numeric ga=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Index picky=Group::Index{0}) {

  psdModifiedGammaMassXmedian(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), Var::scat_species_a(ws).value(), Var::scat_species_b(ws).value(), n0.value(), mu.value(), la.value(), ga.value(), t_min.value(), t_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdMonoDispersive(

            Workspace& ws,

      const Var::Index species_index,

      const Var::Numeric t_min,

      const Var::Numeric t_max,

      const Var::Index picky=Group::Index{0}) {

  psdMonoDispersive(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), Var::scat_meta(ws).value(), species_index.value(), t_min.value(), t_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdMonoMass(

            Workspace& ws,

      const Var::Index species_index,

      const Var::Numeric t_min,

      const Var::Numeric t_max,

      const Var::Index picky=Group::Index{0}) {

  psdMonoMass(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), Var::scat_meta(ws).value(), species_index.value(), t_min.value(), t_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdSeifertBeheng06(

            Workspace& ws,

      const Var::String hydrometeor_type,

      const Var::Numeric t_min=Group::Numeric{0},

      const Var::Numeric t_max=Group::Numeric{999},

      const Var::Index picky=Group::Index{0}) {

  psdSeifertBeheng06(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), hydrometeor_type.value(), t_min.value(), t_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void psdWangEtAl16(

            Workspace& ws,

      const Var::Numeric t_min=Group::Numeric{273},

      const Var::Numeric t_max=Group::Numeric{373},

      const Var::Index picky=Group::Index{0}) {

  psdWangEtAl16(Var::psd_data(ws).value(), Var::dpsd_data_dx(ws).value(), Var::psd_size_grid(ws).value(), Var::pnd_agenda_input_t(ws).value(), Var::pnd_agenda_input(ws).value(), Var::pnd_agenda_input_names(ws).value(), Var::dpnd_data_dx_names(ws).value(), Var::scat_species_a(ws).value(), Var::scat_species_b(ws).value(), t_min.value(), t_max.value(), picky.value(), Var::verbosity(ws).value());

}


inline void p_gridDensify(

            Workspace& ws,

      const Var::Vector p_grid_old,

      const Var::Index nfill=Group::Index{-1}) {

  p_gridDensify(Var::p_grid(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::cloudbox_checked(ws).value(), p_grid_old.value(), nfill.value(), Var::verbosity(ws).value());

}


inline void p_gridFromZRaw(

            Workspace& ws,

      const Var::Index no_negZ=Group::Index{1}) {

  p_gridFromZRaw(Var::p_grid(ws).value(), Var::z_field_raw(ws).value(), no_negZ.value(), Var::verbosity(ws).value());

}


inline void lat_gridFromZRaw(

            Workspace& ws) {

  lat_gridFromZRaw(Var::lat_grid(ws).value(), Var::z_field_raw(ws).value(), Var::verbosity(ws).value());

}


inline void lon_gridFromZRaw(

            Workspace& ws) {

  lon_gridFromZRaw(Var::lon_grid(ws).value(), Var::z_field_raw(ws).value(), Var::verbosity(ws).value());

}


inline void atm_gridsFromZRaw(

            Workspace& ws,

      const Var::Index no_negZ=Group::Index{1}) {

  atm_gridsFromZRaw(Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::z_field_raw(ws).value(), no_negZ.value(), Var::verbosity(ws).value());

}


inline void p_gridFromGasAbsLookup(

            Workspace& ws) {

  p_gridFromGasAbsLookup(Var::p_grid(ws).value(), Var::abs_lookup(ws).value(), Var::verbosity(ws).value());

}


inline void p_gridRefine(

            Workspace& ws,

      const Var::Vector p_grid_old,

      const Var::Numeric p_step) {

  p_gridRefine(Var::p_grid(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::cloudbox_checked(ws).value(), p_grid_old.value(), p_step.value(), Var::verbosity(ws).value());

}


inline void RadiationFieldSpectralIntegrate(

            Workspace& ws,

            Var::Tensor4 radiation_field,

      const Var::Tensor5 spectral_radiation_field) {

  if (radiation_field.islast()) {

    throw std::runtime_error("radiation_field needs to be a defined WorkspaceTensor4 since it is output of RadiationFieldSpectralIntegrate");

  }


  RadiationFieldSpectralIntegrate(radiation_field.value(), Var::f_grid(ws).value(), spectral_radiation_field.value(), Var::verbosity(ws).value());

}


inline void RadiationFieldSpectralIntegrate(

            Workspace& ws,

            Var::Tensor5 radiation_field,

      const Var::Tensor7 spectral_radiation_field) {

  if (radiation_field.islast()) {

    throw std::runtime_error("radiation_field needs to be a defined WorkspaceTensor5 since it is output of RadiationFieldSpectralIntegrate");

  }


  RadiationFieldSpectralIntegrate(radiation_field.value(), Var::f_grid(ws).value(), spectral_radiation_field.value(), Var::verbosity(ws).value());

}


inline void line_irradianceCalcForSingleSpeciesNonOverlappingLinesPseudo2D(

            Workspace& ws,

      const Var::Numeric df,

      const Var::Index nz,

      const Var::Index nf,

      const Var::Numeric r=Group::Numeric{1.0}) {

  line_irradianceCalcForSingleSpeciesNonOverlappingLinesPseudo2D(ws, Var::line_irradiance(ws).value(), Var::line_transmission(ws).value(), Var::abs_species(ws).value(), Var::abs_lines_per_species(ws).value(), Var::nlte_field(ws).value(), Var::vmr_field(ws).value(), Var::t_field(ws).value(), Var::z_field(ws).value(), Var::p_grid(ws).value(), Var::refellipsoid(ws).value(), Var::surface_props_data(ws).value(), Var::iy_main_agenda(ws).value(), Var::ppath_agenda(ws).value(), Var::iy_space_agenda(ws).value(), Var::iy_surface_agenda(ws).value(), Var::iy_cloudbox_agenda(ws).value(), Var::propmat_clearsky_agenda(ws).value(), df.value(), nz.value(), nf.value(), r.value(), Var::verbosity(ws).value());

}


inline void RationalAdd(

            Workspace& ws,

            Var::Rational out,

      const Var::Rational in,

      const Var::Rational value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRational since it is output of RationalAdd");

  }


  RationalAdd(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void RationalInvScale(

            Workspace& ws,

            Var::Rational out,

      const Var::Rational in,

      const Var::Rational value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRational since it is output of RationalInvScale");

  }


  RationalInvScale(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void RationalScale(

            Workspace& ws,

            Var::Rational out,

      const Var::Rational in,

      const Var::Rational value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRational since it is output of RationalScale");

  }


  RationalScale(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void RationalSet(

            Workspace& ws,

            Var::Rational out,

      const Var::Index numerator,

      const Var::Index denominator=Group::Index{1}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRational since it is output of RationalSet");

  }


  RationalSet(out.value(), numerator.value(), denominator.value(), Var::verbosity(ws).value());

}


inline void ReadArrayOfARTSCAT(

            Workspace& ws,

      const Var::String filename,

      const Var::Numeric fmin=Group::Numeric{0},

      const Var::Numeric fmax=Group::Numeric{1e99},

      const Var::String globalquantumnumbers=Group::String{""},

      const Var::String localquantumnumbers=Group::String{""},

      const Var::String normalization_option=Group::String{"None"},

      const Var::String mirroring_option=Group::String{"None"},

      const Var::String population_option=Group::String{"LTE"},

      const Var::String lineshapetype_option=Group::String{"VP"},

      const Var::String cutoff_option=Group::String{"None"},

      const Var::Numeric cutoff_value=Group::Numeric{750e9},

      const Var::Numeric linemixinglimit_value=Group::Numeric{-1}) {

  ReadArrayOfARTSCAT(Var::abs_lines(ws).value(), filename.value(), fmin.value(), fmax.value(), globalquantumnumbers.value(), localquantumnumbers.value(), normalization_option.value(), mirroring_option.value(), population_option.value(), lineshapetype_option.value(), cutoff_option.value(), cutoff_value.value(), linemixinglimit_value.value(), Var::verbosity(ws).value());

}


inline void ReadSplitARTSCAT(

            Workspace& ws,

      const Var::String basename,

      const Var::Numeric fmin=Group::Numeric{0},

      const Var::Numeric fmax=Group::Numeric{1e99},

      const Var::String globalquantumnumbers=Group::String{""},

      const Var::String localquantumnumbers=Group::String{""},

      const Var::Index ignore_missing=Group::Index{0},

      const Var::String normalization_option=Group::String{"None"},

      const Var::String mirroring_option=Group::String{"None"},

      const Var::String population_option=Group::String{"LTE"},

      const Var::String lineshapetype_option=Group::String{"VP"},

      const Var::String cutoff_option=Group::String{"None"},

      const Var::Numeric cutoff_value=Group::Numeric{750e9},

      const Var::Numeric linemixinglimit_value=Group::Numeric{-1}) {

  ReadSplitARTSCAT(Var::abs_lines(ws).value(), Var::abs_species(ws).value(), basename.value(), fmin.value(), fmax.value(), globalquantumnumbers.value(), localquantumnumbers.value(), ignore_missing.value(), normalization_option.value(), mirroring_option.value(), population_option.value(), lineshapetype_option.value(), cutoff_option.value(), cutoff_value.value(), linemixinglimit_value.value(), Var::verbosity(ws).value());

}


inline void ReadARTSCAT(

            Workspace& ws,

      const Var::String filename,

      const Var::Numeric fmin=Group::Numeric{0},

      const Var::Numeric fmax=Group::Numeric{1e99},

      const Var::String globalquantumnumbers=Group::String{""},

      const Var::String localquantumnumbers=Group::String{""},

      const Var::String normalization_option=Group::String{"None"},

      const Var::String mirroring_option=Group::String{"None"},

      const Var::String population_option=Group::String{"LTE"},

      const Var::String lineshapetype_option=Group::String{"VP"},

      const Var::String cutoff_option=Group::String{"None"},

      const Var::Numeric cutoff_value=Group::Numeric{750e9},

      const Var::Numeric linemixinglimit_value=Group::Numeric{-1}) {

  ReadARTSCAT(Var::abs_lines(ws).value(), filename.value(), fmin.value(), fmax.value(), globalquantumnumbers.value(), localquantumnumbers.value(), normalization_option.value(), mirroring_option.value(), population_option.value(), lineshapetype_option.value(), cutoff_option.value(), cutoff_value.value(), linemixinglimit_value.value(), Var::verbosity(ws).value());

}


inline void ReadHITRAN(

            Workspace& ws,

      const Var::String filename,

      const Var::Numeric fmin=Group::Numeric{0},

      const Var::Numeric fmax=Group::Numeric{1e99},

      const Var::String globalquantumnumbers=Group::String{""},

      const Var::String localquantumnumbers=Group::String{""},

      const Var::String hitran_type=Group::String{"Post2004"},

      const Var::String normalization_option=Group::String{"None"},

      const Var::String mirroring_option=Group::String{"None"},

      const Var::String population_option=Group::String{"LTE"},

      const Var::String lineshapetype_option=Group::String{"VP"},

      const Var::String cutoff_option=Group::String{"None"},

      const Var::Numeric cutoff_value=Group::Numeric{750e9},

      const Var::Numeric linemixinglimit_value=Group::Numeric{-1}) {

  ReadHITRAN(Var::abs_lines(ws).value(), filename.value(), fmin.value(), fmax.value(), globalquantumnumbers.value(), localquantumnumbers.value(), hitran_type.value(), normalization_option.value(), mirroring_option.value(), population_option.value(), lineshapetype_option.value(), cutoff_option.value(), cutoff_value.value(), linemixinglimit_value.value(), Var::verbosity(ws).value());

}


inline void ReadLBLRTM(

            Workspace& ws,

      const Var::String filename,

      const Var::Numeric fmin=Group::Numeric{0},

      const Var::Numeric fmax=Group::Numeric{1e99},

      const Var::String globalquantumnumbers=Group::String{""},

      const Var::String localquantumnumbers=Group::String{""},

      const Var::String normalization_option=Group::String{"None"},

      const Var::String mirroring_option=Group::String{"None"},

      const Var::String population_option=Group::String{"LTE"},

      const Var::String lineshapetype_option=Group::String{"VP"},

      const Var::String cutoff_option=Group::String{"None"},

      const Var::Numeric cutoff_value=Group::Numeric{750e9},

      const Var::Numeric linemixinglimit_value=Group::Numeric{-1}) {

  ReadLBLRTM(Var::abs_lines(ws).value(), filename.value(), fmin.value(), fmax.value(), globalquantumnumbers.value(), localquantumnumbers.value(), normalization_option.value(), mirroring_option.value(), population_option.value(), lineshapetype_option.value(), cutoff_option.value(), cutoff_value.value(), linemixinglimit_value.value(), Var::verbosity(ws).value());

}


inline void ReadMytran2(

            Workspace& ws,

      const Var::String filename,

      const Var::Numeric fmin=Group::Numeric{0},

      const Var::Numeric fmax=Group::Numeric{1e99},

      const Var::String globalquantumnumbers=Group::String{""},

      const Var::String localquantumnumbers=Group::String{""},

      const Var::String normalization_option=Group::String{"None"},

      const Var::String mirroring_option=Group::String{"None"},

      const Var::String population_option=Group::String{"LTE"},

      const Var::String lineshapetype_option=Group::String{"VP"},

      const Var::String cutoff_option=Group::String{"None"},

      const Var::Numeric cutoff_value=Group::Numeric{750e9},

      const Var::Numeric linemixinglimit_value=Group::Numeric{-1}) {

  ReadMytran2(Var::abs_lines(ws).value(), filename.value(), fmin.value(), fmax.value(), globalquantumnumbers.value(), localquantumnumbers.value(), normalization_option.value(), mirroring_option.value(), population_option.value(), lineshapetype_option.value(), cutoff_option.value(), cutoff_value.value(), linemixinglimit_value.value(), Var::verbosity(ws).value());

}


inline void ReadJPL(

            Workspace& ws,

      const Var::String filename,

      const Var::Numeric fmin=Group::Numeric{0},

      const Var::Numeric fmax=Group::Numeric{1e99},

      const Var::String globalquantumnumbers=Group::String{""},

      const Var::String localquantumnumbers=Group::String{""},

      const Var::String normalization_option=Group::String{"None"},

      const Var::String mirroring_option=Group::String{"None"},

      const Var::String population_option=Group::String{"LTE"},

      const Var::String lineshapetype_option=Group::String{"VP"},

      const Var::String cutoff_option=Group::String{"None"},

      const Var::Numeric cutoff_value=Group::Numeric{750e9},

      const Var::Numeric linemixinglimit_value=Group::Numeric{-1}) {

  ReadJPL(Var::abs_lines(ws).value(), filename.value(), fmin.value(), fmax.value(), globalquantumnumbers.value(), localquantumnumbers.value(), normalization_option.value(), mirroring_option.value(), population_option.value(), lineshapetype_option.value(), cutoff_option.value(), cutoff_value.value(), linemixinglimit_value.value(), Var::verbosity(ws).value());

}


inline void abs_linesTruncateGlobalQuantumNumbers(

            Workspace& ws) {

  abs_linesTruncateGlobalQuantumNumbers(Var::abs_lines(ws).value(), Var::verbosity(ws).value());

}


inline void abs_linesWriteSplitXML(

            Workspace& ws,

      const Var::String basename) {

  abs_linesWriteSplitXML(Var::output_file_format(ws).value(), Var::abs_lines(ws).value(), basename.value(), Var::verbosity(ws).value());

}


inline void abs_linesWriteSpeciesSplitXML(

            Workspace& ws,

      const Var::String basename) {

  abs_linesWriteSpeciesSplitXML(Var::output_file_format(ws).value(), Var::abs_lines(ws).value(), basename.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesWriteSplitXML(

            Workspace& ws,

      const Var::String basename) {

  abs_lines_per_speciesWriteSplitXML(Var::output_file_format(ws).value(), Var::abs_lines_per_species(ws).value(), basename.value(), Var::verbosity(ws).value());

}


inline void abs_lines_per_speciesWriteSpeciesSplitXML(

            Workspace& ws,

      const Var::String basename) {

  abs_lines_per_speciesWriteSpeciesSplitXML(Var::output_file_format(ws).value(), Var::abs_lines_per_species(ws).value(), basename.value(), Var::verbosity(ws).value());

}


inline void ReadNetCDF(

            Workspace& ws,

            Var::Vector out,

      const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of ReadNetCDF");

  }


  ReadNetCDF(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadNetCDF(

            Workspace& ws,

            Var::Matrix out,

      const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of ReadNetCDF");

  }


  ReadNetCDF(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadNetCDF(

            Workspace& ws,

            Var::Tensor3 out,

      const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of ReadNetCDF");

  }


  ReadNetCDF(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadNetCDF(

            Workspace& ws,

            Var::Tensor4 out,

      const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of ReadNetCDF");

  }


  ReadNetCDF(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadNetCDF(

            Workspace& ws,

            Var::Tensor5 out,

      const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor5 since it is output of ReadNetCDF");

  }


  ReadNetCDF(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadNetCDF(

            Workspace& ws,

            Var::ArrayOfVector out,

      const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of ReadNetCDF");

  }


  ReadNetCDF(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadNetCDF(

            Workspace& ws,

            Var::ArrayOfMatrix out,

      const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfMatrix since it is output of ReadNetCDF");

  }


  ReadNetCDF(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadNetCDF(

            Workspace& ws,

            Var::GasAbsLookup out,

      const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGasAbsLookup since it is output of ReadNetCDF");

  }


  ReadNetCDF(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::AbsorptionLines out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceAbsorptionLines since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Agenda out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceAgenda since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfAbsorptionLines out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAbsorptionLines since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfAbsorptionLines out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfAgenda out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAgenda since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField1 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField2 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField3 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfIndex out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfIndex since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfMatrix out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfPpath out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPpath since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfPropagationMatrix out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfRadiationVector out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfScatteringMetaData out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfSingleScatteringData out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfSpeciesTag out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfStokesVector out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfString out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfString since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfTensor3 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfTensor6 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfTime out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTime since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfTransmissionMatrix out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfArrayOfVector out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfVector since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfCIARecord out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfCIARecord since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfGriddedField1 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField1 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfGriddedField2 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField2 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfGriddedField3 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfGriddedField4 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField4 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfIndex out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfMatrix out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfMatrix since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfPropagationMatrix out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPropagationMatrix since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfQuantumIdentifier out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfRadiationVector out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRadiationVector since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfRetrievalQuantity out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfScatteringMetaData out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfScatteringMetaData since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfSingleScatteringData out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfSparse out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSparse since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfStokesVector out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfStokesVector since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfString out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfString since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfTelsemAtlas out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTelsemAtlas since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfTensor3 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor3 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfTensor4 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor4 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfTensor5 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor5 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfTensor6 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor6 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfTensor7 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor7 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfTime out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTime since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfTransmissionMatrix out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfVector out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ArrayOfXsecRecord out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfXsecRecord since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::CIARecord out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceCIARecord since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::CovarianceMatrix out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceCovarianceMatrix since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::EnergyLevelMap out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceEnergyLevelMap since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::GasAbsLookup out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGasAbsLookup since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::GridPos out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGridPos since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::GriddedField1 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField1 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::GriddedField2 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField2 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::GriddedField3 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField3 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::GriddedField4 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField4 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::GriddedField5 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField5 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::GriddedField6 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField6 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::HitranRelaxationMatrixData out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceHitranRelaxationMatrixData since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Index out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::MCAntenna out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMCAntenna since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Matrix out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Numeric out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Ppath out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspacePpath since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::PropagationMatrix out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspacePropagationMatrix since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::QuantumIdentifier out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceQuantumIdentifier since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::RadiationVector out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRadiationVector since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Rational out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRational since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::ScatteringMetaData out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceScatteringMetaData since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::SingleScatteringData out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSingleScatteringData since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Sparse out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::SpeciesAuxData out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSpeciesAuxData since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::StokesVector out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceStokesVector since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::String out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceString since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::TelsemAtlas out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTelsemAtlas since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Tensor3 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Tensor4 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Tensor5 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor5 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Tensor6 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor6 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Tensor7 out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor7 since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Timer out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTimer since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Time out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTime since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::TessemNN out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTessemNN since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::TransmissionMatrix out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTransmissionMatrix since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Vector out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXML(

            Workspace& ws,

            Var::Verbosity out,

      const Var::String filename=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVerbosity since it is output of ReadXML");

  }


  ReadXML(out.value(), out.name(), filename.value(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::AbsorptionLines out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceAbsorptionLines since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Agenda out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceAgenda since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfAbsorptionLines out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAbsorptionLines since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfAbsorptionLines out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfAgenda out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAgenda since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField1 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField2 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField3 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfIndex out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfIndex since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfMatrix out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfPpath out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPpath since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfPropagationMatrix out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfRadiationVector out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfScatteringMetaData out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfSingleScatteringData out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfSpeciesTag out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfStokesVector out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfString out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfString since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfTensor3 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfTensor6 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfTime out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTime since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfTransmissionMatrix out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfArrayOfVector out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfVector since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfCIARecord out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfCIARecord since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfGriddedField1 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField1 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfGriddedField2 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField2 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfGriddedField3 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfGriddedField4 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField4 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfIndex out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfMatrix out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfMatrix since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfPropagationMatrix out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPropagationMatrix since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfQuantumIdentifier out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfRadiationVector out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRadiationVector since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfRetrievalQuantity out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfScatteringMetaData out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfScatteringMetaData since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfSingleScatteringData out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfSparse out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSparse since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfStokesVector out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfStokesVector since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfString out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfString since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfTelsemAtlas out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTelsemAtlas since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfTensor3 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor3 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfTensor4 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor4 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfTensor5 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor5 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfTensor6 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor6 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfTensor7 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor7 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfTime out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTime since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfTransmissionMatrix out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfVector out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ArrayOfXsecRecord out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfXsecRecord since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::CIARecord out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceCIARecord since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::CovarianceMatrix out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceCovarianceMatrix since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::EnergyLevelMap out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceEnergyLevelMap since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::GasAbsLookup out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGasAbsLookup since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::GridPos out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGridPos since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::GriddedField1 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField1 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::GriddedField2 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField2 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::GriddedField3 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField3 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::GriddedField4 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField4 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::GriddedField5 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField5 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::GriddedField6 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField6 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::HitranRelaxationMatrixData out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceHitranRelaxationMatrixData since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Index out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::MCAntenna out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMCAntenna since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Matrix out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Numeric out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Ppath out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspacePpath since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::PropagationMatrix out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspacePropagationMatrix since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::QuantumIdentifier out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceQuantumIdentifier since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::RadiationVector out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRadiationVector since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Rational out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRational since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::ScatteringMetaData out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceScatteringMetaData since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::SingleScatteringData out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSingleScatteringData since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Sparse out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::SpeciesAuxData out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSpeciesAuxData since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::StokesVector out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceStokesVector since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::String out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceString since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::TelsemAtlas out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTelsemAtlas since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Tensor3 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Tensor4 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Tensor5 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor5 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Tensor6 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor6 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Tensor7 out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor7 since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Timer out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTimer since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Time out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTime since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::TessemNN out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTessemNN since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::TransmissionMatrix out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTransmissionMatrix since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Vector out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void ReadXMLIndexed(

            Workspace& ws,

            Var::Verbosity out,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVerbosity since it is output of ReadXMLIndexed");

  }


  ReadXMLIndexed(out.value(), out.name(), Var::file_index(ws).value(), filename.value(), digits.value(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Numeric o,

      const Var::Vector i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceNumeric since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Numeric o,

      const Var::Matrix i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceNumeric since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Numeric o,

      const Var::Tensor3 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceNumeric since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Numeric o,

      const Var::Tensor4 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceNumeric since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Numeric o,

      const Var::Tensor5 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceNumeric since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Numeric o,

      const Var::Tensor6 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceNumeric since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Numeric o,

      const Var::Tensor7 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceNumeric since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Vector o,

      const Var::Matrix i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceVector since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Vector o,

      const Var::Tensor3 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceVector since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Vector o,

      const Var::Tensor4 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceVector since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Vector o,

      const Var::Tensor5 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceVector since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Vector o,

      const Var::Tensor6 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceVector since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Vector o,

      const Var::Tensor7 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceVector since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Matrix o,

      const Var::Tensor3 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceMatrix since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Matrix o,

      const Var::Tensor4 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceMatrix since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Matrix o,

      const Var::Tensor5 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceMatrix since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Matrix o,

      const Var::Tensor6 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceMatrix since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Matrix o,

      const Var::Tensor7 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceMatrix since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Tensor3 o,

      const Var::Tensor4 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor3 since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Tensor3 o,

      const Var::Tensor5 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor3 since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Tensor3 o,

      const Var::Tensor6 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor3 since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Tensor3 o,

      const Var::Tensor7 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor3 since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Tensor4 o,

      const Var::Tensor5 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor4 since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Tensor4 o,

      const Var::Tensor6 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor4 since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Tensor4 o,

      const Var::Tensor7 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor4 since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Tensor5 o,

      const Var::Tensor6 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor5 since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Tensor5 o,

      const Var::Tensor7 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor5 since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void Reduce(

            Workspace& ws,

            Var::Tensor6 o,

      const Var::Tensor7 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor6 since it is output of Reduce");

  }


  Reduce(o.value(), i.value(), Var::verbosity(ws).value());

}


inline void refellipsoidEarth(

            Workspace& ws,

      const Var::String model=Group::String{"Sphere"}) {

  refellipsoidEarth(Var::refellipsoid(ws).value(), model.value(), Var::verbosity(ws).value());

}


inline void refellipsoidGanymede(

            Workspace& ws,

      const Var::String model=Group::String{"Sphere"}) {

  refellipsoidGanymede(Var::refellipsoid(ws).value(), model.value(), Var::verbosity(ws).value());

}


inline void refellipsoidForAzimuth(

            Workspace& ws,

      const Var::Numeric latitude,

      const Var::Numeric azimuth) {

  refellipsoidForAzimuth(Var::refellipsoid(ws).value(), latitude.value(), azimuth.value(), Var::verbosity(ws).value());

}


inline void refellipsoidEuropa(

            Workspace& ws,

      const Var::String model=Group::String{"Sphere"}) {

  refellipsoidEuropa(Var::refellipsoid(ws).value(), model.value(), Var::verbosity(ws).value());

}


inline void refellipsoidIo(

            Workspace& ws,

      const Var::String model=Group::String{"Sphere"}) {

  refellipsoidIo(Var::refellipsoid(ws).value(), model.value(), Var::verbosity(ws).value());

}


inline void refellipsoidJupiter(

            Workspace& ws,

      const Var::String model=Group::String{"Sphere"}) {

  refellipsoidJupiter(Var::refellipsoid(ws).value(), model.value(), Var::verbosity(ws).value());

}


inline void refellipsoidMars(

            Workspace& ws,

      const Var::String model=Group::String{"Sphere"}) {

  refellipsoidMars(Var::refellipsoid(ws).value(), model.value(), Var::verbosity(ws).value());

}


inline void refellipsoidMoon(

            Workspace& ws,

      const Var::String model=Group::String{"Sphere"}) {

  refellipsoidMoon(Var::refellipsoid(ws).value(), model.value(), Var::verbosity(ws).value());

}


inline void refellipsoidOrbitPlane(

            Workspace& ws,

      const Var::Numeric orbitinc) {

  refellipsoidOrbitPlane(Var::refellipsoid(ws).value(), orbitinc.value(), Var::verbosity(ws).value());

}


inline void refellipsoidSet(

            Workspace& ws,

      const Var::Numeric re,

      const Var::Numeric e=Group::Numeric{0}) {

  refellipsoidSet(Var::refellipsoid(ws).value(), re.value(), e.value(), Var::verbosity(ws).value());

}


inline void refellipsoidVenus(

            Workspace& ws,

      const Var::String model=Group::String{"Sphere"}) {

  refellipsoidVenus(Var::refellipsoid(ws).value(), model.value(), Var::verbosity(ws).value());

}


inline void refr_index_airFreeElectrons(

            Workspace& ws,

      const Var::Index demand_vmr_value=Group::Index{1}) {

  refr_index_airFreeElectrons(Var::refr_index_air(ws).value(), Var::refr_index_air_group(ws).value(), Var::f_grid(ws).value(), Var::abs_species(ws).value(), Var::rtp_vmr(ws).value(), demand_vmr_value.value(), Var::verbosity(ws).value());

}


inline void refr_index_airInfraredEarth(

            Workspace& ws) {

  refr_index_airInfraredEarth(Var::refr_index_air(ws).value(), Var::refr_index_air_group(ws).value(), Var::rtp_pressure(ws).value(), Var::rtp_temperature(ws).value(), Var::verbosity(ws).value());

}


inline void refr_index_airMicrowavesEarth(

            Workspace& ws,

      const Var::Numeric k1=Group::Numeric{77.6e-8},

      const Var::Numeric k2=Group::Numeric{70.4e-8},

      const Var::Numeric k3=Group::Numeric{3.739e-3}) {

  refr_index_airMicrowavesEarth(Var::refr_index_air(ws).value(), Var::refr_index_air_group(ws).value(), Var::rtp_pressure(ws).value(), Var::rtp_temperature(ws).value(), Var::rtp_vmr(ws).value(), Var::abs_species(ws).value(), k1.value(), k2.value(), k3.value(), Var::verbosity(ws).value());

}


inline void refr_index_airMicrowavesGeneral(

            Workspace& ws) {

  refr_index_airMicrowavesGeneral(Var::refr_index_air(ws).value(), Var::refr_index_air_group(ws).value(), Var::rtp_pressure(ws).value(), Var::rtp_temperature(ws).value(), Var::rtp_vmr(ws).value(), Var::abs_species(ws).value(), Var::verbosity(ws).value());

}


inline void retrievalDefClose(

            Workspace& ws) {

  retrievalDefClose(ws, Var::jacobian_do(ws).value(), Var::jacobian_agenda(ws).value(), Var::retrieval_checked(ws).value(), Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::verbosity(ws).value());

}


inline void retrievalAddAbsSpecies(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::Vector g3,

      const Var::String species,

      const Var::String unit=Group::String{"rel"},

      const Var::Index for_species_tag=Group::Index{1}) {

  retrievalAddAbsSpecies(ws, Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::covmat_block(ws).value(), Var::covmat_inv_block(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), g3.value(), species.value(), unit.value(), for_species_tag.value(), Var::verbosity(ws).value());

}


inline void retrievalAddFreqShift(

            Workspace& ws,

      const Var::Numeric df=Group::Numeric{100e3}) {

  retrievalAddFreqShift(ws, Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::covmat_block(ws).value(), Var::covmat_inv_block(ws).value(), Var::f_grid(ws).value(), df.value(), Var::verbosity(ws).value());

}


inline void retrievalAddFreqStretch(

            Workspace& ws,

      const Var::Numeric df=Group::Numeric{100e3}) {

  retrievalAddFreqStretch(ws, Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::f_grid(ws).value(), Var::covmat_block(ws).value(), Var::covmat_inv_block(ws).value(), df.value(), Var::verbosity(ws).value());

}


inline void retrievalDefInit(

            Workspace& ws,

      const Var::Index initialize_jacobian=Group::Index{1}) {

  retrievalDefInit(Var::covmat_se(ws).value(), Var::covmat_sx(ws).value(), Var::covmat_block(ws).value(), Var::covmat_inv_block(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), initialize_jacobian.value(), Var::verbosity(ws).value());

}


inline void retrievalAddCatalogParameter(

            Workspace& ws,

      const Var::QuantumIdentifier catalog_identity,

      const Var::String catalog_parameter,

      const Var::Numeric var) {

  retrievalAddCatalogParameter(ws, Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), catalog_identity.value(), catalog_parameter.value(), var.value(), Var::verbosity(ws).value());

}


inline void retrievalAddCatalogParameters(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier catalog_identities,

      const Var::ArrayOfString catalog_parameters) {

  retrievalAddCatalogParameters(ws, Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::covmat_block(ws).value(), Var::covmat_inv_block(ws).value(), catalog_identities.value(), catalog_parameters.value(), Var::verbosity(ws).value());

}


inline void retrievalAddMagField(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::Vector g3,

      const Var::String component=Group::String{"v"},

      const Var::Numeric dB=Group::Numeric{1.0e-7}) {

  retrievalAddMagField(ws, Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::covmat_block(ws).value(), Var::covmat_inv_block(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), g3.value(), component.value(), dB.value(), Var::verbosity(ws).value());

}


inline void retrievalAddPointingZa(

            Workspace& ws,

      const Var::Index poly_order=Group::Index{0},

      const Var::String calcmode=Group::String{"recalc"},

      const Var::Numeric dza=Group::Numeric{0.01}) {

  retrievalAddPointingZa(ws, Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::covmat_block(ws).value(), Var::covmat_inv_block(ws).value(), Var::sensor_pos(ws).value(), Var::sensor_time(ws).value(), poly_order.value(), calcmode.value(), dza.value(), Var::verbosity(ws).value());

}


inline void retrievalAddPolyfit(

            Workspace& ws,

      const Var::Index poly_order,

      const Var::Index no_pol_variation=Group::Index{0},

      const Var::Index no_los_variation=Group::Index{0},

      const Var::Index no_mblock_variation=Group::Index{0}) {

  retrievalAddPolyfit(ws, Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::covmat_block(ws).value(), Var::covmat_inv_block(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::sensor_pos(ws).value(), poly_order.value(), no_pol_variation.value(), no_los_variation.value(), no_mblock_variation.value(), Var::verbosity(ws).value());

}


inline void retrievalAddScatSpecies(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::Vector g3,

      const Var::String species,

      const Var::String quantity) {

  retrievalAddScatSpecies(ws, Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::covmat_block(ws).value(), Var::covmat_inv_block(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), g3.value(), species.value(), quantity.value(), Var::verbosity(ws).value());

}


inline void retrievalAddSinefit(

            Workspace& ws,

      const Var::Vector period_lengths,

      const Var::Index no_pol_variation=Group::Index{0},

      const Var::Index no_los_variation=Group::Index{0},

      const Var::Index no_mblock_variation=Group::Index{0}) {

  retrievalAddSinefit(ws, Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::covmat_block(ws).value(), Var::covmat_inv_block(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::sensor_pos(ws).value(), period_lengths.value(), no_pol_variation.value(), no_los_variation.value(), no_mblock_variation.value(), Var::verbosity(ws).value());

}


inline void retrievalAddSpecialSpecies(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::Vector g3,

      const Var::String species) {

  retrievalAddSpecialSpecies(ws, Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::covmat_block(ws).value(), Var::covmat_inv_block(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), g3.value(), species.value(), Var::verbosity(ws).value());

}


inline void retrievalAddSurfaceQuantity(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::String quantity) {

  retrievalAddSurfaceQuantity(ws, Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::covmat_block(ws).value(), Var::covmat_inv_block(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), quantity.value(), Var::verbosity(ws).value());

}


inline void retrievalAddTemperature(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::Vector g3,

      const Var::String hse=Group::String{"on"}) {

  retrievalAddTemperature(ws, Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::covmat_block(ws).value(), Var::covmat_inv_block(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), g3.value(), hse.value(), Var::verbosity(ws).value());

}


inline void retrievalAddWind(

            Workspace& ws,

      const Var::Vector g1,

      const Var::Vector g2,

      const Var::Vector g3,

      const Var::String component=Group::String{"v"},

      const Var::Numeric dfrequency=Group::Numeric{0.1}) {

  retrievalAddWind(ws, Var::covmat_sx(ws).value(), Var::jacobian_quantities(ws).value(), Var::jacobian_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::covmat_block(ws).value(), Var::covmat_inv_block(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), g1.value(), g2.value(), g3.value(), component.value(), dfrequency.value(), Var::verbosity(ws).value());

}


inline void retrievalErrorsExtract(

            Workspace& ws) {

  retrievalErrorsExtract(Var::retrieval_eo(ws).value(), Var::retrieval_ss(ws).value(), Var::covmat_so(ws).value(), Var::covmat_ss(ws).value(), Var::verbosity(ws).value());

}


inline void RT4Calc(

            Workspace& ws,

      const Var::Index nstreams=Group::Index{16},

      const Var::String pfct_method=Group::String{"median"},

      const Var::String quad_type=Group::String{"D"},

      const Var::Index add_straight_angles=Group::Index{1},

      const Var::Index pfct_aa_grid_size=Group::Index{19},

      const Var::Index auto_inc_nstreams=Group::Index{0},

      const Var::Index robust=Group::Index{0},

      const Var::Index za_interp_order=Group::Index{1},

      const Var::Index cos_za_interp=Group::Index{0},

      const Var::Numeric max_delta_tau=Group::Numeric{1e-6}) {

  RT4Calc(ws, Var::cloudbox_field(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::scat_data_checked(ws).value(), Var::cloudbox_checked(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::surface_rtprop_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::pnd_field(ws).value(), Var::t_field(ws).value(), Var::z_field(ws).value(), Var::vmr_field(ws).value(), Var::p_grid(ws).value(), Var::scat_data(ws).value(), Var::f_grid(ws).value(), Var::stokes_dim(ws).value(), Var::z_surface(ws).value(), nstreams.value(), pfct_method.value(), quad_type.value(), add_straight_angles.value(), pfct_aa_grid_size.value(), auto_inc_nstreams.value(), robust.value(), za_interp_order.value(), cos_za_interp.value(), max_delta_tau.value(), Var::verbosity(ws).value());

}


inline void RT4CalcWithRT4Surface(

            Workspace& ws,

      const Var::Index nstreams=Group::Index{16},

      const Var::String pfct_method=Group::String{"median"},

      const Var::String ground_type=Group::String{"A"},

      const Var::String quad_type=Group::String{"D"},

      const Var::Index add_straight_angles=Group::Index{1},

      const Var::Index pfct_aa_grid_size=Group::Index{19},

      const Var::Index auto_inc_nstreams=Group::Index{0},

      const Var::Index robust=Group::Index{0},

      const Var::Index za_interp_order=Group::Index{1},

      const Var::Index cos_za_interp=Group::Index{0},

      const Var::Numeric max_delta_tau=Group::Numeric{1e-6}) {

  RT4CalcWithRT4Surface(ws, Var::cloudbox_field(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::scat_data_checked(ws).value(), Var::cloudbox_checked(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::atmosphere_dim(ws).value(), Var::pnd_field(ws).value(), Var::t_field(ws).value(), Var::z_field(ws).value(), Var::vmr_field(ws).value(), Var::p_grid(ws).value(), Var::scat_data(ws).value(), Var::f_grid(ws).value(), Var::stokes_dim(ws).value(), Var::z_surface(ws).value(), Var::surface_skin_t(ws).value(), Var::surface_scalar_reflectivity(ws).value(), Var::surface_reflectivity(ws).value(), Var::surface_complex_refr_index(ws).value(), nstreams.value(), pfct_method.value(), ground_type.value(), quad_type.value(), add_straight_angles.value(), pfct_aa_grid_size.value(), auto_inc_nstreams.value(), robust.value(), za_interp_order.value(), cos_za_interp.value(), max_delta_tau.value(), Var::verbosity(ws).value());

}


inline void RT4Test(

            Workspace& ws,

            Var::Tensor4 out_rad,

      const Var::String datapath=Group::String{"artscomponents/polradtran/testdata/"}) {

  if (out_rad.islast()) {

    throw std::runtime_error("out_rad needs to be a defined WorkspaceTensor4 since it is output of RT4Test");

  }


  RT4Test(out_rad.value(), datapath.value(), Var::verbosity(ws).value());

}


inline void rte_losGeometricFromRtePosToRtePos2(

            Workspace& ws) {

  rte_losGeometricFromRtePosToRtePos2(Var::rte_los(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::refellipsoid(ws).value(), Var::rte_pos(ws).value(), Var::rte_pos2(ws).value(), Var::verbosity(ws).value());

}


inline void rte_losSet(

            Workspace& ws,

      const Var::Numeric za,

      const Var::Numeric aa) {

  rte_losSet(Var::rte_los(ws).value(), Var::atmosphere_dim(ws).value(), za.value(), aa.value(), Var::verbosity(ws).value());

}


inline void rte_posSet(

            Workspace& ws,

      const Var::Numeric z,

      const Var::Numeric lat,

      const Var::Numeric lon) {

  rte_posSet(Var::rte_pos(ws).value(), Var::atmosphere_dim(ws).value(), z.value(), lat.value(), lon.value(), Var::verbosity(ws).value());

}


inline void rte_pos_losMoveToStartOfPpath(

            Workspace& ws) {

  rte_pos_losMoveToStartOfPpath(Var::rte_pos(ws).value(), Var::rte_los(ws).value(), Var::atmosphere_dim(ws).value(), Var::ppath(ws).value(), Var::verbosity(ws).value());

}


inline void rtp_nlteFromRaw(

            Workspace& ws,

      const Var::Vector data) {

  rtp_nlteFromRaw(Var::rtp_nlte(ws).value(), Var::nlte_level_identifiers(ws).value(), Var::nlte_vibrational_energies(ws).value(), data.value(), Var::verbosity(ws).value());

}


inline void ScatElementsPndAndScatAdd(

            Workspace& ws,

      const Var::ArrayOfString scat_data_files,

      const Var::ArrayOfString pnd_field_files) {

  ScatElementsPndAndScatAdd(Var::scat_data_raw(ws).value(), Var::pnd_field_raw(ws).value(), Var::atmosphere_dim(ws).value(), scat_data_files.value(), pnd_field_files.value(), Var::verbosity(ws).value());

}


inline void ScatElementsSelect(

            Workspace& ws,

      const Var::String species,

      const Var::String sizeparam,

      const Var::Numeric sizemin=Group::Numeric{0.},

      const Var::Numeric sizemax=Group::Numeric{-1.},

      const Var::Numeric tolerance=Group::Numeric{1e-6},

      const Var::String delim=Group::String{"-"}) {

  ScatElementsSelect(Var::scat_data_raw(ws).value(), Var::scat_meta(ws).value(), Var::scat_species(ws).value(), species.value(), sizeparam.value(), sizemin.value(), sizemax.value(), tolerance.value(), delim.value(), Var::verbosity(ws).value());

}


inline void ScatElementsToabs_speciesAdd(

            Workspace& ws,

      const Var::ArrayOfString scat_data_files,

      const Var::ArrayOfString pnd_field_files) {

  ScatElementsToabs_speciesAdd(Var::scat_data_raw(ws).value(), Var::vmr_field_raw(ws).value(), Var::abs_species(ws).value(), Var::propmat_clearsky_agenda_checked(ws).value(), Var::abs_xsec_agenda_checked(ws).value(), Var::atmosphere_dim(ws).value(), Var::f_grid(ws).value(), scat_data_files.value(), pnd_field_files.value(), Var::verbosity(ws).value());

}


inline void ScatSpeciesExtendTemperature(

            Workspace& ws,

      const Var::String species=Group::String{""},

      const Var::String scat_species_delim=Group::String{"-"},

      const Var::Numeric T_low=Group::Numeric{-1.},

      const Var::Numeric T_high=Group::Numeric{-1.}) {

  ScatSpeciesExtendTemperature(Var::scat_data_raw(ws).value(), Var::scat_species(ws).value(), species.value(), scat_species_delim.value(), T_low.value(), T_high.value(), Var::verbosity(ws).value());

}


inline void ScatSpeciesInit(

            Workspace& ws) {

  ScatSpeciesInit(Var::scat_species(ws).value(), Var::scat_data_raw(ws).value(), Var::scat_meta(ws).value(), Var::scat_data_checked(ws).value(), Var::pnd_field_raw(ws).value(), Var::verbosity(ws).value());

}


inline void ScatSpeciesMerge(

            Workspace& ws) {

  ScatSpeciesMerge(Var::pnd_field(ws).value(), Var::scat_data(ws).value(), Var::scat_meta(ws).value(), Var::scat_species(ws).value(), Var::cloudbox_checked(ws).value(), Var::atmosphere_dim(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::t_field(ws).value(), Var::z_field(ws).value(), Var::z_surface(ws).value(), Var::verbosity(ws).value());

}


inline void ScatSpeciesPndAndScatAdd(

            Workspace& ws,

      const Var::ArrayOfString scat_data_files,

      const Var::String pnd_fieldarray_file) {

  ScatSpeciesPndAndScatAdd(Var::scat_data_raw(ws).value(), Var::pnd_field_raw(ws).value(), Var::atmosphere_dim(ws).value(), scat_data_files.value(), pnd_fieldarray_file.value(), Var::verbosity(ws).value());

}


inline void ScatSpeciesScatAndMetaRead(

            Workspace& ws,

      const Var::ArrayOfString scat_data_files) {

  ScatSpeciesScatAndMetaRead(Var::scat_data_raw(ws).value(), Var::scat_meta(ws).value(), scat_data_files.value(), Var::verbosity(ws).value());

}


inline void scat_data_singleTmatrix(

            Workspace& ws,

      const Var::String shape,

      const Var::Numeric diameter_volume_equ,

      const Var::Numeric aspect_ratio,

      const Var::String ptype,

      const Var::Vector data_f_grid,

      const Var::Vector data_t_grid,

      const Var::Vector data_za_grid,

      const Var::Numeric mass=Group::Numeric{std::numeric_limits<Numeric>::quiet_NaN()},

      const Var::Vector data_aa_grid=Group::Vector{},

      const Var::Numeric precision=Group::Numeric{0.001},

      const Var::String cri_source=Group::String{"Set by user, unknown source."},

      const Var::Index ndgs=Group::Index{2},

      const Var::Index robust=Group::Index{0},

      const Var::Index quiet=Group::Index{1}) {

  scat_data_singleTmatrix(Var::scat_data_single(ws).value(), Var::scat_meta_single(ws).value(), Var::complex_refr_index(ws).value(), shape.value(), diameter_volume_equ.value(), aspect_ratio.value(), mass.value(), ptype.value(), data_f_grid.value(), data_t_grid.value(), data_za_grid.value(), data_aa_grid.value(), precision.value(), cri_source.value(), ndgs.value(), robust.value(), quiet.value(), Var::verbosity(ws).value());

}


inline void scat_data_checkedCalc(

            Workspace& ws,

      const Var::Numeric dfrel_threshold=Group::Numeric{0.1},

      const Var::String check_level=Group::String{"all"},

      const Var::Numeric sca_mat_threshold=Group::Numeric{5e-2}) {

  scat_data_checkedCalc(Var::scat_data_checked(ws).value(), Var::scat_data(ws).value(), Var::f_grid(ws).value(), dfrel_threshold.value(), check_level.value(), sca_mat_threshold.value(), Var::verbosity(ws).value());

}


inline void scat_data_monoCalc(

            Workspace& ws) {

  scat_data_monoCalc(Var::scat_data_mono(ws).value(), Var::scat_data(ws).value(), Var::f_grid(ws).value(), Var::f_index(ws).value(), Var::verbosity(ws).value());

}


inline void scat_data_monoExtract(

            Workspace& ws) {

  scat_data_monoExtract(Var::scat_data_mono(ws).value(), Var::scat_data(ws).value(), Var::f_index(ws).value(), Var::verbosity(ws).value());

}


inline void scat_dataCalc(

            Workspace& ws,

      const Var::Index interp_order=Group::Index{1}) {

  scat_dataCalc(Var::scat_data(ws).value(), Var::scat_data_raw(ws).value(), Var::f_grid(ws).value(), interp_order.value(), Var::verbosity(ws).value());

}


inline void scat_dataCheck(

            Workspace& ws,

      const Var::String check_type=Group::String{"all"},

      const Var::Numeric sca_mat_threshold=Group::Numeric{5e-2}) {

  scat_dataCheck(Var::scat_data(ws).value(), check_type.value(), sca_mat_threshold.value(), Var::verbosity(ws).value());

}


inline void scat_dataReduceT(

            Workspace& ws,

      const Var::Index scat_index,

      const Var::Numeric temperature,

      const Var::Index interp_order=Group::Index{1},

      const Var::Index phamat_only=Group::Index{1},

      const Var::Numeric sca_mat_threshold=Group::Numeric{5e-2}) {

  scat_dataReduceT(Var::scat_data(ws).value(), scat_index.value(), temperature.value(), interp_order.value(), phamat_only.value(), sca_mat_threshold.value(), Var::verbosity(ws).value());

}


inline void ScatSpeciesSizeMassInfo(

            Workspace& ws,

      const Var::Index species_index,

      const Var::String x_unit,

      const Var::Numeric x_fit_start=Group::Numeric{0},

      const Var::Numeric x_fit_end=Group::Numeric{1e9},

      const Var::Index do_only_x=Group::Index{0}) {

  ScatSpeciesSizeMassInfo(Var::scat_species_x(ws).value(), Var::scat_species_a(ws).value(), Var::scat_species_b(ws).value(), Var::scat_meta(ws).value(), species_index.value(), x_unit.value(), x_fit_start.value(), x_fit_end.value(), do_only_x.value(), Var::verbosity(ws).value());

}


inline void particle_fieldCleanup(

            Workspace& ws,

            Var::Tensor4 particle_field_out,

      const Var::Tensor4 particle_field_in,

      const Var::Numeric threshold) {

  if (particle_field_out.islast()) {

    throw std::runtime_error("particle_field_out needs to be a defined WorkspaceTensor4 since it is output of particle_fieldCleanup");

  }


  particle_fieldCleanup(particle_field_out.value(), particle_field_in.value(), threshold.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfAbsorptionLines needles,

      const Var::ArrayOfAbsorptionLines haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfAbsorptionLines since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfAbsorptionLines needles,

      const Var::ArrayOfArrayOfAbsorptionLines haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfAgenda needles,

      const Var::ArrayOfAgenda haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfAgenda since it is output of Select");

  }


  Select(ws, needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField1 needles,

      const Var::ArrayOfArrayOfGriddedField1 haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField2 needles,

      const Var::ArrayOfArrayOfGriddedField2 haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField3 needles,

      const Var::ArrayOfArrayOfGriddedField3 haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfIndex needles,

      const Var::ArrayOfArrayOfIndex haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfIndex since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfMatrix needles,

      const Var::ArrayOfArrayOfMatrix haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfPpath needles,

      const Var::ArrayOfPpath haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfPpath since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfPropagationMatrix needles,

      const Var::ArrayOfArrayOfPropagationMatrix haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfRadiationVector needles,

      const Var::ArrayOfArrayOfRadiationVector haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfScatteringMetaData needles,

      const Var::ArrayOfArrayOfScatteringMetaData haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfSingleScatteringData needles,

      const Var::ArrayOfArrayOfSingleScatteringData haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfSpeciesTag needles,

      const Var::ArrayOfArrayOfSpeciesTag haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfStokesVector needles,

      const Var::ArrayOfArrayOfStokesVector haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfString needles,

      const Var::ArrayOfArrayOfString haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfString since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfTensor3 needles,

      const Var::ArrayOfArrayOfTensor3 haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfTensor6 needles,

      const Var::ArrayOfArrayOfTensor6 haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfTime needles,

      const Var::ArrayOfArrayOfTime haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfTime since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfTransmissionMatrix needles,

      const Var::ArrayOfArrayOfTransmissionMatrix haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfArrayOfVector needles,

      const Var::ArrayOfArrayOfVector haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfVector since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfCIARecord needles,

      const Var::ArrayOfCIARecord haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfCIARecord since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfGriddedField1 needles,

      const Var::ArrayOfGriddedField1 haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfGriddedField1 since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfGriddedField2 needles,

      const Var::ArrayOfGriddedField2 haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfGriddedField2 since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfGriddedField3 needles,

      const Var::ArrayOfGriddedField3 haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfGriddedField4 needles,

      const Var::ArrayOfGriddedField4 haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfGriddedField4 since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfIndex needles,

      const Var::ArrayOfIndex haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfIndex since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfMatrix needles,

      const Var::ArrayOfMatrix haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfMatrix since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfPropagationMatrix needles,

      const Var::ArrayOfPropagationMatrix haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfPropagationMatrix since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfQuantumIdentifier needles,

      const Var::ArrayOfQuantumIdentifier haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfRadiationVector needles,

      const Var::ArrayOfRadiationVector haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfRadiationVector since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfRetrievalQuantity needles,

      const Var::ArrayOfRetrievalQuantity haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfScatteringMetaData needles,

      const Var::ArrayOfScatteringMetaData haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfScatteringMetaData since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfSingleScatteringData needles,

      const Var::ArrayOfSingleScatteringData haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfSparse needles,

      const Var::ArrayOfSparse haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfSparse since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfStokesVector needles,

      const Var::ArrayOfStokesVector haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfStokesVector since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfString needles,

      const Var::ArrayOfString haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfString since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfTelsemAtlas needles,

      const Var::ArrayOfTelsemAtlas haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTelsemAtlas since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfTensor3 needles,

      const Var::ArrayOfTensor3 haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTensor3 since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfTensor4 needles,

      const Var::ArrayOfTensor4 haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTensor4 since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfTensor5 needles,

      const Var::ArrayOfTensor5 haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTensor5 since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfTensor6 needles,

      const Var::ArrayOfTensor6 haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTensor6 since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfTensor7 needles,

      const Var::ArrayOfTensor7 haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTensor7 since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfTime needles,

      const Var::ArrayOfTime haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTime since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfTransmissionMatrix needles,

      const Var::ArrayOfTransmissionMatrix haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfVector needles,

      const Var::ArrayOfVector haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfVector since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::ArrayOfXsecRecord needles,

      const Var::ArrayOfXsecRecord haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfXsecRecord since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::Vector needles,

      const Var::Vector haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceVector since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::Matrix needles,

      const Var::Matrix haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceMatrix since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void Select(

            Workspace& ws,

            Var::Sparse needles,

      const Var::Sparse haystack,

      const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceSparse since it is output of Select");

  }


  Select(needles.value(), haystack.value(), needleindexes.value(), Var::verbosity(ws).value());

}


inline void sensor_checkedCalc(

            Workspace& ws) {

  sensor_checkedCalc(Var::sensor_checked(ws).value(), Var::atmosphere_dim(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::sensor_pos(ws).value(), Var::sensor_los(ws).value(), Var::transmitter_pos(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::verbosity(ws).value());

}


inline void sensorOff(

            Workspace& ws) {

  sensorOff(Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::verbosity(ws).value());

}


inline void sensor_losGeometricFromSensorPosToOtherPositions(

            Workspace& ws,

      const Var::Matrix target_pos) {

  sensor_losGeometricFromSensorPosToOtherPositions(Var::sensor_los(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::refellipsoid(ws).value(), Var::sensor_pos(ws).value(), target_pos.value(), Var::verbosity(ws).value());

}


inline void sensor_responseAntenna(

            Workspace& ws,

      const Var::String option_2d=Group::String{"-"}) {

  sensor_responseAntenna(Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::antenna_dim(ws).value(), Var::antenna_dlos(ws).value(), Var::antenna_response(ws).value(), Var::sensor_norm(ws).value(), option_2d.value(), Var::verbosity(ws).value());

}


inline void sensor_responseBackend(

            Workspace& ws) {

  sensor_responseBackend(Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::f_backend(ws).value(), Var::backend_channel_response(ws).value(), Var::sensor_norm(ws).value(), Var::verbosity(ws).value());

}


inline void sensor_responseBackendFrequencySwitching(

            Workspace& ws,

      const Var::Numeric df1,

      const Var::Numeric df2) {

  sensor_responseBackendFrequencySwitching(Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::f_backend(ws).value(), Var::backend_channel_response(ws).value(), Var::sensor_norm(ws).value(), df1.value(), df2.value(), Var::verbosity(ws).value());

}


inline void sensor_responseBeamSwitching(

            Workspace& ws,

      const Var::Numeric w1=Group::Numeric{-1},

      const Var::Numeric w2=Group::Numeric{1}) {

  sensor_responseBeamSwitching(Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), w1.value(), w2.value(), Var::verbosity(ws).value());

}


inline void sensor_responseFillFgrid(

            Workspace& ws,

      const Var::Index polyorder=Group::Index{3},

      const Var::Index nfill=Group::Index{2}) {

  sensor_responseFillFgrid(Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), polyorder.value(), nfill.value(), Var::verbosity(ws).value());

}


inline void sensor_responseFrequencySwitching(

            Workspace& ws) {

  sensor_responseFrequencySwitching(Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::verbosity(ws).value());

}


inline void sensor_responseIF2RF(

            Workspace& ws) {

  sensor_responseIF2RF(Var::sensor_response_f(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::lo(ws).value(), Var::sideband_mode(ws).value(), Var::verbosity(ws).value());

}


inline void sensor_responseInit(

            Workspace& ws) {

  sensor_responseInit(Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::f_grid(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::antenna_dim(ws).value(), Var::atmosphere_dim(ws).value(), Var::stokes_dim(ws).value(), Var::sensor_norm(ws).value(), Var::verbosity(ws).value());

}


inline void sensor_responseMetMM(

            Workspace& ws,

      const Var::Index use_antenna=Group::Index{0},

      const Var::Index mirror_dza=Group::Index{0}) {

  sensor_responseMetMM(Var::antenna_dim(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::sensor_norm(ws).value(), Var::atmosphere_dim(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::f_backend(ws).value(), Var::channel2fgrid_indexes(ws).value(), Var::channel2fgrid_weights(ws).value(), Var::iy_unit(ws).value(), Var::antenna_dlos(ws).value(), Var::met_mm_polarisation(ws).value(), Var::met_mm_antenna(ws).value(), use_antenna.value(), mirror_dza.value(), Var::verbosity(ws).value());

}


inline void sensor_responseMixer(

            Workspace& ws) {

  sensor_responseMixer(Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::lo(ws).value(), Var::sideband_response(ws).value(), Var::sensor_norm(ws).value(), Var::verbosity(ws).value());

}


inline void sensor_responseMixerBackendPrecalcWeights(

            Workspace& ws) {

  sensor_responseMixerBackendPrecalcWeights(Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::f_backend(ws).value(), Var::channel2fgrid_indexes(ws).value(), Var::channel2fgrid_weights(ws).value(), Var::verbosity(ws).value());

}


inline void sensor_responseMultiMixerBackend(

            Workspace& ws) {

  sensor_responseMultiMixerBackend(Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::lo_multi(ws).value(), Var::sideband_response_multi(ws).value(), Var::sideband_mode_multi(ws).value(), Var::f_backend_multi(ws).value(), Var::backend_channel_response_multi(ws).value(), Var::sensor_norm(ws).value(), Var::verbosity(ws).value());

}


inline void sensor_responsePolarisation(

            Workspace& ws) {

  sensor_responsePolarisation(Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::stokes_dim(ws).value(), Var::iy_unit(ws).value(), Var::instrument_pol(ws).value(), Var::verbosity(ws).value());

}


inline void sensor_responseStokesRotation(

            Workspace& ws) {

  sensor_responseStokesRotation(Var::sensor_response(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::stokes_dim(ws).value(), Var::stokes_rotation(ws).value(), Var::verbosity(ws).value());

}


inline void sensor_responseSimpleAMSU(

            Workspace& ws,

      const Var::Numeric spacing=Group::Numeric{.1e9}) {

  sensor_responseSimpleAMSU(Var::f_grid(ws).value(), Var::antenna_dim(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::sensor_norm(ws).value(), Var::atmosphere_dim(ws).value(), Var::stokes_dim(ws).value(), Var::sensor_description_amsu(ws).value(), spacing.value(), Var::verbosity(ws).value());

}


inline void sensor_responseGenericAMSU(

            Workspace& ws,

      const Var::Numeric spacing=Group::Numeric{.1e9}) {

  sensor_responseGenericAMSU(Var::f_grid(ws).value(), Var::antenna_dim(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::sensor_norm(ws).value(), Var::atmosphere_dim(ws).value(), Var::stokes_dim(ws).value(), Var::sensor_description_amsu(ws).value(), spacing.value(), Var::verbosity(ws).value());

}


inline void sensor_responseWMRF(

            Workspace& ws) {

  sensor_responseWMRF(Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::wmrf_weights(ws).value(), Var::f_backend(ws).value(), Var::verbosity(ws).value());

}


inline void SetNumberOfThreads(

            Workspace& ws,

      const Var::Index nthreads) {

  SetNumberOfThreads(nthreads.value(), Var::verbosity(ws).value());

}


inline void Sleep(

            Workspace& ws,

      const Var::Numeric time) {

  Sleep(time.value(), Var::verbosity(ws).value());

}


inline void timeSleep(

            Workspace& ws) {

  timeSleep(Var::time(ws).value(), Var::verbosity(ws).value());

}


inline void SparseSparseMultiply(

            Workspace& ws,

            Var::Sparse out,

      const Var::Sparse m1,

      const Var::Sparse m2) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of SparseSparseMultiply");

  }


  SparseSparseMultiply(out.value(), m1.value(), m2.value(), Var::verbosity(ws).value());

}


inline void SparseMatrixIdentity(

            Workspace& ws,

            Var::Sparse out,

      const Var::Index n,

      const Var::Numeric value=Group::Numeric{1}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of SparseMatrixIdentity");

  }


  SparseMatrixIdentity(out.value(), n.value(), value.value(), Var::verbosity(ws).value());

}


inline void spectral_irradiance_fieldFromSpectralRadianceField(

            Workspace& ws) {

  spectral_irradiance_fieldFromSpectralRadianceField(Var::spectral_irradiance_field(ws).value(), Var::spectral_radiance_field(ws).value(), Var::za_grid(ws).value(), Var::aa_grid(ws).value(), Var::za_grid_weights(ws).value(), Var::verbosity(ws).value());

}


inline void spectral_radiance_fieldClearskyPlaneParallel(

            Workspace& ws,

            Var::Tensor3 trans_field,

      const Var::Index use_parallel_iy=Group::Index{0}) {

  if (trans_field.islast()) {

    throw std::runtime_error("trans_field needs to be a defined WorkspaceTensor3 since it is output of spectral_radiance_fieldClearskyPlaneParallel");

  }


  spectral_radiance_fieldClearskyPlaneParallel(ws, Var::spectral_radiance_field(ws).value(), trans_field.value(), Var::propmat_clearsky_agenda(ws).value(), Var::water_p_eq_agenda(ws).value(), Var::iy_space_agenda(ws).value(), Var::iy_surface_agenda(ws).value(), Var::iy_cloudbox_agenda(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::z_field(ws).value(), Var::t_field(ws).value(), Var::nlte_field(ws).value(), Var::vmr_field(ws).value(), Var::abs_species(ws).value(), Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::z_surface(ws).value(), Var::ppath_lmax(ws).value(), Var::rte_alonglos_v(ws).value(), Var::surface_props_data(ws).value(), Var::za_grid(ws).value(), use_parallel_iy.value(), Var::verbosity(ws).value());

}


inline void spectral_radiance_fieldCopyCloudboxField(

            Workspace& ws) {

  spectral_radiance_fieldCopyCloudboxField(Var::spectral_radiance_field(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::cloudbox_field(ws).value(), Var::verbosity(ws).value());

}


inline void spectral_radiance_fieldExpandCloudboxField(

            Workspace& ws,

      const Var::Index use_parallel_iy=Group::Index{0}) {

  spectral_radiance_fieldExpandCloudboxField(ws, Var::spectral_radiance_field(ws).value(), Var::propmat_clearsky_agenda(ws).value(), Var::water_p_eq_agenda(ws).value(), Var::iy_space_agenda(ws).value(), Var::iy_surface_agenda(ws).value(), Var::iy_cloudbox_agenda(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::z_field(ws).value(), Var::t_field(ws).value(), Var::nlte_field(ws).value(), Var::vmr_field(ws).value(), Var::abs_species(ws).value(), Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::z_surface(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_limits(ws).value(), Var::cloudbox_field(ws).value(), Var::ppath_lmax(ws).value(), Var::rte_alonglos_v(ws).value(), Var::surface_props_data(ws).value(), Var::za_grid(ws).value(), use_parallel_iy.value(), Var::verbosity(ws).value());

}


inline void specular_losCalc(

            Workspace& ws,

      const Var::Index ignore_surface_slope=Group::Index{0}) {

  specular_losCalc(Var::specular_los(ws).value(), Var::surface_normal(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::refellipsoid(ws).value(), Var::z_surface(ws).value(), ignore_surface_slope.value(), Var::verbosity(ws).value());

}


inline void specular_losCalcNoTopography(

            Workspace& ws) {

  specular_losCalcNoTopography(Var::specular_los(ws).value(), Var::surface_normal(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::atmosphere_dim(ws).value(), Var::verbosity(ws).value());

}


inline void StringJoin(

            Workspace& ws,

            Var::String out,

      const Var::String in1,

      const Var::String in2,

      const Var::String in3=Group::String{""},

      const Var::String in4=Group::String{""},

      const Var::String in5=Group::String{""},

      const Var::String in6=Group::String{""},

      const Var::String in7=Group::String{""},

      const Var::String in8=Group::String{""},

      const Var::String in9=Group::String{""},

      const Var::String in10=Group::String{""}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceString since it is output of StringJoin");

  }


  StringJoin(out.value(), in1.value(), in2.value(), in3.value(), in4.value(), in5.value(), in6.value(), in7.value(), in8.value(), in9.value(), in10.value(), Var::verbosity(ws).value());

}


inline void StringSet(

            Workspace& ws,

            Var::String out,

      const Var::String text) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceString since it is output of StringSet");

  }


  StringSet(out.value(), text.value(), Var::verbosity(ws).value());

}


inline void z_surfaceFromFileAndGrid(

            Workspace& ws,

      const Var::String filename,

      const Var::Index interp_order=Group::Index{1},

      const Var::Index set_lowest_altitude_to_zero=Group::Index{0}) {

  z_surfaceFromFileAndGrid(Var::z_surface(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), filename.value(), interp_order.value(), set_lowest_altitude_to_zero.value(), Var::verbosity(ws).value());

}


inline void z_surfaceConstantAltitude(

            Workspace& ws,

      const Var::Numeric altitude=Group::Numeric{0}) {

  z_surfaceConstantAltitude(Var::z_surface(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), altitude.value(), Var::verbosity(ws).value());

}


inline void surfaceBlackbody(

            Workspace& ws) {

  surfaceBlackbody(Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::surface_emission(ws).value(), Var::atmosphere_dim(ws).value(), Var::f_grid(ws).value(), Var::stokes_dim(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::surface_skin_t(ws).value(), Var::verbosity(ws).value());

}


inline void surfaceFastem(

            Workspace& ws,

      const Var::Numeric wind_speed,

      const Var::Vector transmittance,

      const Var::Numeric salinity=Group::Numeric{0.035},

      const Var::Numeric wind_direction=Group::Numeric{0},

      const Var::Index fastem_version=Group::Index{6}) {

  surfaceFastem(Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::surface_emission(ws).value(), Var::atmosphere_dim(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::surface_skin_t(ws).value(), salinity.value(), wind_speed.value(), wind_direction.value(), transmittance.value(), fastem_version.value(), Var::verbosity(ws).value());

}


inline void surfaceTessem(

            Workspace& ws,

      const Var::Numeric wind_speed,

      const Var::Numeric salinity=Group::Numeric{0.035}) {

  surfaceTessem(Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::surface_emission(ws).value(), Var::atmosphere_dim(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::surface_skin_t(ws).value(), Var::tessem_neth(ws).value(), Var::tessem_netv(ws).value(), salinity.value(), wind_speed.value(), Var::verbosity(ws).value());

}


inline void surfaceTelsem(

            Workspace& ws,

      const Var::TelsemAtlas atlas,

      const Var::Numeric r_min=Group::Numeric{0},

      const Var::Numeric r_max=Group::Numeric{1},

      const Var::Numeric d_max=Group::Numeric{-1.0}) {

  surfaceTelsem(Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::surface_emission(ws).value(), Var::atmosphere_dim(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::lat_grid(ws).value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::surface_skin_t(ws).value(), atlas.value(), r_min.value(), r_max.value(), d_max.value(), Var::verbosity(ws).value());

}


inline void surfaceFlatRefractiveIndex(

            Workspace& ws) {

  surfaceFlatRefractiveIndex(Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::surface_emission(ws).value(), Var::f_grid(ws).value(), Var::stokes_dim(ws).value(), Var::atmosphere_dim(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::specular_los(ws).value(), Var::surface_skin_t(ws).value(), Var::surface_complex_refr_index(ws).value(), Var::verbosity(ws).value());

}


inline void surfaceFlatReflectivity(

            Workspace& ws) {

  surfaceFlatReflectivity(Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::surface_emission(ws).value(), Var::f_grid(ws).value(), Var::stokes_dim(ws).value(), Var::atmosphere_dim(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::specular_los(ws).value(), Var::surface_skin_t(ws).value(), Var::surface_reflectivity(ws).value(), Var::verbosity(ws).value());

}


inline void surfaceFlatRvRh(

            Workspace& ws) {

  surfaceFlatRvRh(Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::surface_emission(ws).value(), Var::f_grid(ws).value(), Var::stokes_dim(ws).value(), Var::atmosphere_dim(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::specular_los(ws).value(), Var::surface_skin_t(ws).value(), Var::surface_rv_rh(ws).value(), Var::verbosity(ws).value());

}


inline void surfaceFlatScalarReflectivity(

            Workspace& ws) {

  surfaceFlatScalarReflectivity(Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::surface_emission(ws).value(), Var::f_grid(ws).value(), Var::stokes_dim(ws).value(), Var::atmosphere_dim(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::specular_los(ws).value(), Var::surface_skin_t(ws).value(), Var::surface_scalar_reflectivity(ws).value(), Var::verbosity(ws).value());

}


inline void surfaceLambertianSimple(

            Workspace& ws,

      const Var::Index lambertian_nza=Group::Index{9},

      const Var::Numeric za_pos=Group::Numeric{0.5}) {

  surfaceLambertianSimple(Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::surface_emission(ws).value(), Var::f_grid(ws).value(), Var::stokes_dim(ws).value(), Var::atmosphere_dim(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::surface_normal(ws).value(), Var::surface_skin_t(ws).value(), Var::surface_scalar_reflectivity(ws).value(), lambertian_nza.value(), za_pos.value(), Var::verbosity(ws).value());

}


inline void surfaceSemiSpecularBy3beams(

            Workspace& ws,

      const Var::Numeric specular_factor,

      const Var::Numeric dza) {

  surfaceSemiSpecularBy3beams(ws, Var::surface_skin_t(ws).value(), Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::surface_emission(ws).value(), Var::atmosphere_dim(ws).value(), Var::f_grid(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::surface_rtprop_sub_agenda(ws).value(), specular_factor.value(), dza.value(), Var::verbosity(ws).value());

}


inline void surfaceSplitSpecularTo3beams(

            Workspace& ws,

      const Var::Numeric specular_factor,

      const Var::Numeric dza) {

  surfaceSplitSpecularTo3beams(Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::atmosphere_dim(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), specular_factor.value(), dza.value(), Var::verbosity(ws).value());

}


inline void surface_complex_refr_indexFromGriddedField5(

            Workspace& ws,

      const Var::GriddedField5 complex_refr_index_field) {

  surface_complex_refr_indexFromGriddedField5(Var::surface_complex_refr_index(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), Var::rtp_pos(ws).value(), complex_refr_index_field.value(), Var::verbosity(ws).value());

}


inline void surface_reflectivityFromGriddedField6(

            Workspace& ws,

      const Var::GriddedField6 r_field) {

  surface_reflectivityFromGriddedField6(Var::surface_reflectivity(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), r_field.value(), Var::verbosity(ws).value());

}


inline void surface_rtpropCallAgendaX(

            Workspace& ws) {

  surface_rtpropCallAgendaX(ws, Var::surface_skin_t(ws).value(), Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::surface_emission(ws).value(), Var::f_grid(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::surface_rtprop_agenda_array(ws).value(), Var::surface_type(ws).value(), Var::surface_type_aux(ws).value(), Var::verbosity(ws).value());

}


inline void surface_scalar_reflectivityFromGriddedField4(

            Workspace& ws,

      const Var::GriddedField4 r_field) {

  surface_scalar_reflectivityFromGriddedField4(Var::surface_scalar_reflectivity(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), r_field.value(), Var::verbosity(ws).value());

}


inline void surface_scalar_reflectivityFromSurface_rmatrix(

            Workspace& ws) {

  surface_scalar_reflectivityFromSurface_rmatrix(Var::surface_scalar_reflectivity(ws).value(), Var::surface_rmatrix(ws).value(), Var::verbosity(ws).value());

}


inline void surface_typeInterpTypeMask(

            Workspace& ws) {

  surface_typeInterpTypeMask(Var::surface_type(ws).value(), Var::surface_type_aux(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), Var::rtp_pos(ws).value(), Var::surface_type_mask(ws).value(), Var::verbosity(ws).value());

}


inline void SurfaceDummy(

            Workspace& ws) {

  SurfaceDummy(Var::dsurface_rmatrix_dx(ws).value(), Var::dsurface_emission_dx(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::surface_props_data(ws).value(), Var::surface_props_names(ws).value(), Var::dsurface_names(ws).value(), Var::jacobian_do(ws).value(), Var::verbosity(ws).value());

}


inline void SurfaceFastem(

            Workspace& ws,

      const Var::Vector transmittance,

      const Var::Index fastem_version=Group::Index{6}) {

  SurfaceFastem(Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::dsurface_rmatrix_dx(ws).value(), Var::surface_emission(ws).value(), Var::dsurface_emission_dx(ws).value(), Var::stokes_dim(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::f_grid(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::surface_props_data(ws).value(), Var::surface_props_names(ws).value(), Var::dsurface_names(ws).value(), Var::jacobian_do(ws).value(), transmittance.value(), fastem_version.value(), Var::verbosity(ws).value());

}


inline void SurfaceTessem(

            Workspace& ws) {

  SurfaceTessem(Var::surface_los(ws).value(), Var::surface_rmatrix(ws).value(), Var::dsurface_rmatrix_dx(ws).value(), Var::surface_emission(ws).value(), Var::dsurface_emission_dx(ws).value(), Var::stokes_dim(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::f_grid(ws).value(), Var::rtp_pos(ws).value(), Var::rtp_los(ws).value(), Var::tessem_neth(ws).value(), Var::tessem_netv(ws).value(), Var::surface_props_data(ws).value(), Var::surface_props_names(ws).value(), Var::dsurface_names(ws).value(), Var::jacobian_do(ws).value(), Var::verbosity(ws).value());

}


inline void TangentPointExtract(

            Workspace& ws,

            Var::Vector tan_pos) {

  if (tan_pos.islast()) {

    throw std::runtime_error("tan_pos needs to be a defined WorkspaceVector since it is output of TangentPointExtract");

  }


  TangentPointExtract(tan_pos.value(), Var::ppath(ws).value(), Var::verbosity(ws).value());

}


inline void TangentPointPrint(

            Workspace& ws,

      const Var::Index level=Group::Index{1}) {

  TangentPointPrint(Var::ppath(ws).value(), level.value(), Var::verbosity(ws).value());

}


inline void telsemStandalone(

            Workspace& ws,

            Var::Matrix emissivities,

      const Var::Numeric lat,

      const Var::Numeric lon,

      const Var::Numeric theta,

      const Var::Vector f,

      const Var::TelsemAtlas ta,

      const Var::Numeric d_max=Group::Numeric{-1}) {

  if (emissivities.islast()) {

    throw std::runtime_error("emissivities needs to be a defined WorkspaceMatrix since it is output of telsemStandalone");

  }


  telsemStandalone(emissivities.value(), lat.value(), lon.value(), theta.value(), f.value(), ta.value(), d_max.value(), Var::verbosity(ws).value());

}


inline void telsemAtlasLookup(

            Workspace& ws,

            Var::Vector emissivities,

      const Var::Numeric lat,

      const Var::Numeric lon,

      const Var::TelsemAtlas atlas) {

  if (emissivities.islast()) {

    throw std::runtime_error("emissivities needs to be a defined WorkspaceVector since it is output of telsemAtlasLookup");

  }


  telsemAtlasLookup(emissivities.value(), lat.value(), lon.value(), atlas.value(), Var::verbosity(ws).value());

}


inline void telsemSurfaceTypeLandSea(

            Workspace& ws,

      const Var::TelsemAtlas atlas) {

  telsemSurfaceTypeLandSea(Var::surface_type(ws).value(), Var::atmosphere_dim(ws).value(), Var::lat_grid(ws).value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), Var::rtp_pos(ws).value(), atlas.value(), Var::verbosity(ws).value());

}


inline void telsem_atlasReadAscii(

            Workspace& ws,

            Var::TelsemAtlas atlas,

      const Var::String directory,

      const Var::Index month,

      const Var::String filename_pattern=Group::String{"ssmi_mean_emis_climato_@MM@_cov_interpol_M2"}) {

  if (atlas.islast()) {

    throw std::runtime_error("atlas needs to be a defined WorkspaceTelsemAtlas since it is output of telsem_atlasReadAscii");

  }


  telsem_atlasReadAscii(atlas.value(), directory.value(), month.value(), filename_pattern.value(), Var::verbosity(ws).value());

}


inline void telsem_atlasesReadAscii(

            Workspace& ws,

      const Var::String directory,

      const Var::String filename_pattern=Group::String{"ssmi_mean_emis_climato_@MM@_cov_interpol_M2"}) {

  telsem_atlasesReadAscii(Var::telsem_atlases(ws).value(), directory.value(), filename_pattern.value(), Var::verbosity(ws).value());

}


inline void Tensor3AddScalar(

            Workspace& ws,

            Var::Tensor3 out,

      const Var::Tensor3 in,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Tensor3AddScalar");

  }


  Tensor3AddScalar(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void Tensor3ExtractFromTensor4(

            Workspace& ws,

            Var::Tensor3 out,

      const Var::Tensor4 in,

      const Var::Index i,

      const Var::String direction) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Tensor3ExtractFromTensor4");

  }


  Tensor3ExtractFromTensor4(out.value(), in.value(), i.value(), direction.value(), Var::verbosity(ws).value());

}


inline void Tensor3Scale(

            Workspace& ws,

            Var::Tensor3 out,

      const Var::Tensor3 in,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Tensor3Scale");

  }


  Tensor3Scale(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void Tensor3SetConstant(

            Workspace& ws,

            Var::Tensor3 out,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Tensor3SetConstant");

  }


  Tensor3SetConstant(out.value(), Var::npages(ws).value(), Var::nrows(ws).value(), Var::ncols(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void Tensor4AddScalar(

            Workspace& ws,

            Var::Tensor4 out,

      const Var::Tensor4 in,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of Tensor4AddScalar");

  }


  Tensor4AddScalar(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void Tensor4Scale(

            Workspace& ws,

            Var::Tensor4 out,

      const Var::Tensor4 in,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of Tensor4Scale");

  }


  Tensor4Scale(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void Tensor4SetConstant(

            Workspace& ws,

            Var::Tensor4 out,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of Tensor4SetConstant");

  }


  Tensor4SetConstant(out.value(), Var::nbooks(ws).value(), Var::npages(ws).value(), Var::nrows(ws).value(), Var::ncols(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void Tensor5Scale(

            Workspace& ws,

            Var::Tensor5 out,

      const Var::Tensor5 in,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor5 since it is output of Tensor5Scale");

  }


  Tensor5Scale(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void Tensor5SetConstant(

            Workspace& ws,

            Var::Tensor5 out,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor5 since it is output of Tensor5SetConstant");

  }


  Tensor5SetConstant(out.value(), Var::nshelves(ws).value(), Var::nbooks(ws).value(), Var::npages(ws).value(), Var::nrows(ws).value(), Var::ncols(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void Tensor6Scale(

            Workspace& ws,

            Var::Tensor6 out,

      const Var::Tensor6 in,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor6 since it is output of Tensor6Scale");

  }


  Tensor6Scale(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void Tensor6SetConstant(

            Workspace& ws,

            Var::Tensor6 out,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor6 since it is output of Tensor6SetConstant");

  }


  Tensor6SetConstant(out.value(), Var::nvitrines(ws).value(), Var::nshelves(ws).value(), Var::nbooks(ws).value(), Var::npages(ws).value(), Var::nrows(ws).value(), Var::ncols(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void Tensor7Scale(

            Workspace& ws,

            Var::Tensor7 out,

      const Var::Tensor7 in,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor7 since it is output of Tensor7Scale");

  }


  Tensor7Scale(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void Tensor7SetConstant(

            Workspace& ws,

            Var::Tensor7 out,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor7 since it is output of Tensor7SetConstant");

  }


  Tensor7SetConstant(out.value(), Var::nlibraries(ws).value(), Var::nvitrines(ws).value(), Var::nshelves(ws).value(), Var::nbooks(ws).value(), Var::npages(ws).value(), Var::nrows(ws).value(), Var::ncols(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void TestArrayOfAgenda(

            Workspace& ws,

      const Var::Index index=Group::Index{0}) {

  TestArrayOfAgenda(ws, Var::test_agenda_array(ws).value(), index.value(), Var::verbosity(ws).value());

}


inline void TessemNNReadAscii(

            Workspace& ws,

            Var::TessemNN tessem_nn,

      const Var::String filename) {

  if (tessem_nn.islast()) {

    throw std::runtime_error("tessem_nn needs to be a defined WorkspaceTessemNN since it is output of TessemNNReadAscii");

  }


  TessemNNReadAscii(tessem_nn.value(), filename.value(), Var::verbosity(ws).value());

}


inline void TestTessem(

            Workspace& ws,

            Var::Vector outvalues,

      const Var::TessemNN net,

      const Var::Vector invalues) {

  if (outvalues.islast()) {

    throw std::runtime_error("outvalues needs to be a defined WorkspaceVector since it is output of TestTessem");

  }


  TestTessem(outvalues.value(), net.value(), invalues.value(), Var::verbosity(ws).value());

}


inline void Test(

            Workspace& ws) {

  Test(Var::verbosity(ws).value());

}


inline void time_gridOffset(

            Workspace& ws,

      const Var::Numeric dt) {

  time_gridOffset(Var::time_grid(ws).value(), dt.value(), Var::verbosity(ws).value());

}


inline void timerStart(

            Workspace& ws) {

  timerStart(Var::timer(ws).value(), Var::verbosity(ws).value());

}


inline void timerStop(

            Workspace& ws) {

  timerStop(Var::timer(ws).value(), Var::verbosity(ws).value());

}


inline void time_stampsSort(

            Workspace& ws,

            Var::ArrayOfTime out,

      const Var::ArrayOfTime in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTime since it is output of time_stampsSort");

  }


  time_stampsSort(out.value(), Var::time_stamps(ws).value(), in.value(), Var::verbosity(ws).value());

}


inline void time_stampsSort(

            Workspace& ws,

            Var::ArrayOfVector out,

      const Var::ArrayOfVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of time_stampsSort");

  }


  time_stampsSort(out.value(), Var::time_stamps(ws).value(), in.value(), Var::verbosity(ws).value());

}


inline void TMatrixTest(

            Workspace& ws) {

  TMatrixTest(Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::AbsorptionLines in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAbsorptionLines since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Agenda in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAgenda since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfAbsorptionLines in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAbsorptionLines since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfAbsorptionLines in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfAgenda in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAgenda since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField1 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField2 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfGriddedField3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfIndex in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfIndex since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfPpath in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPpath since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfPropagationMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfRadiationVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfScatteringMetaData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfSingleScatteringData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfSpeciesTag in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfStokesVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfString in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfString since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfTensor3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfTensor6 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfTime in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTime since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfTransmissionMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfArrayOfVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfVector since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfCIARecord in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfCIARecord since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfGriddedField1 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField1 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfGriddedField2 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField2 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfGriddedField3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfGriddedField4 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField4 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfIndex in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfIndex since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfMatrix since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfPropagationMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPropagationMatrix since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfQuantumIdentifier in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfRadiationVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRadiationVector since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfRetrievalQuantity in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfScatteringMetaData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfScatteringMetaData since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfSingleScatteringData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfSparse in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSparse since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfStokesVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfStokesVector since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfString in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfString since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfTelsemAtlas in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTelsemAtlas since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfTensor3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor3 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfTensor4 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor4 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfTensor5 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor5 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfTensor6 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor6 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfTensor7 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor7 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfTime in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTime since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfTransmissionMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfVector since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ArrayOfXsecRecord in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfXsecRecord since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::CIARecord in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCIARecord since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::CovarianceMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCovarianceMatrix since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::EnergyLevelMap in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceEnergyLevelMap since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::GasAbsLookup in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGasAbsLookup since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::GridPos in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGridPos since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::GriddedField1 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField1 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::GriddedField2 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField2 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::GriddedField3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField3 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::GriddedField4 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField4 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::GriddedField5 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField5 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::GriddedField6 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField6 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::HitranRelaxationMatrixData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceHitranRelaxationMatrixData since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Index in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceIndex since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::MCAntenna in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMCAntenna since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Matrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Numeric in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceNumeric since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Ppath in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePpath since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::PropagationMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePropagationMatrix since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::QuantumIdentifier in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceQuantumIdentifier since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::RadiationVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRadiationVector since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Rational in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRational since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::ScatteringMetaData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceScatteringMetaData since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::SingleScatteringData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSingleScatteringData since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Sparse in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSparse since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::SpeciesAuxData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSpeciesAuxData since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::StokesVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceStokesVector since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::String in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceString since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::TelsemAtlas in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTelsemAtlas since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Tensor3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Tensor4 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Tensor5 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor5 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Tensor6 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor6 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Tensor7 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor7 since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Timer in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTimer since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Time in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTime since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::TessemNN in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTessemNN since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::TransmissionMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTransmissionMatrix since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Vector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void Touch(

            Workspace& ws,

            Var::Verbosity in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVerbosity since it is output of Touch");

  }


  Touch(in.value(), Var::verbosity(ws).value());

}


inline void transmittanceFromIy_aux(

            Workspace& ws,

            Var::Vector transmittance) {

  if (transmittance.islast()) {

    throw std::runtime_error("transmittance needs to be a defined WorkspaceVector since it is output of transmittanceFromIy_aux");

  }


  transmittanceFromIy_aux(transmittance.value(), Var::iy_aux_vars(ws).value(), Var::iy_aux(ws).value(), Var::verbosity(ws).value());

}


inline void VectorAddScalar(

            Workspace& ws,

            Var::Vector out,

      const Var::Vector in,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorAddScalar");

  }


  VectorAddScalar(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void VectorAddVector(

            Workspace& ws,

            Var::Vector c,

      const Var::Vector a,

      const Var::Vector b) {

  if (c.islast()) {

    throw std::runtime_error("c needs to be a defined WorkspaceVector since it is output of VectorAddVector");

  }


  VectorAddVector(c.value(), a.value(), b.value(), Var::verbosity(ws).value());

}


inline void VectorCrop(

            Workspace& ws,

            Var::Vector out,

      const Var::Vector in,

      const Var::Numeric min_value=Group::Numeric{-99e99},

      const Var::Numeric max_value=Group::Numeric{99e99}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorCrop");

  }


  VectorCrop(out.value(), in.value(), min_value.value(), max_value.value(), Var::verbosity(ws).value());

}


inline void VectorExtractFromMatrix(

            Workspace& ws,

            Var::Vector out,

      const Var::Matrix in,

      const Var::Index i,

      const Var::String direction) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorExtractFromMatrix");

  }


  VectorExtractFromMatrix(out.value(), in.value(), i.value(), direction.value(), Var::verbosity(ws).value());

}


inline void VectorFlip(

            Workspace& ws,

            Var::Vector out,

      const Var::Vector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorFlip");

  }


  VectorFlip(out.value(), in.value(), Var::verbosity(ws).value());

}


inline void VectorInsertGridPoints(

            Workspace& ws,

            Var::Vector out,

      const Var::Vector in,

      const Var::Vector points) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorInsertGridPoints");

  }


  VectorInsertGridPoints(out.value(), in.value(), points.value(), Var::verbosity(ws).value());

}


inline void VectorLinSpace(

            Workspace& ws,

            Var::Vector out,

      const Var::Numeric start,

      const Var::Numeric stop,

      const Var::Numeric step) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorLinSpace");

  }


  VectorLinSpace(out.value(), start.value(), stop.value(), step.value(), Var::verbosity(ws).value());

}


inline void VectorLogSpace(

            Workspace& ws,

            Var::Vector out,

      const Var::Numeric start,

      const Var::Numeric stop,

      const Var::Numeric step) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorLogSpace");

  }


  VectorLogSpace(out.value(), start.value(), stop.value(), step.value(), Var::verbosity(ws).value());

}


inline void VectorMatrixMultiply(

            Workspace& ws,

            Var::Vector out,

      const Var::Matrix m,

      const Var::Vector v) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorMatrixMultiply");

  }


  VectorMatrixMultiply(out.value(), m.value(), v.value(), Var::verbosity(ws).value());

}


inline void VectorNLinSpace(

            Workspace& ws,

            Var::Vector out,

      const Var::Numeric start,

      const Var::Numeric stop) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorNLinSpace");

  }


  VectorNLinSpace(out.value(), Var::nelem(ws).value(), start.value(), stop.value(), Var::verbosity(ws).value());

}


inline void VectorNLogSpace(

            Workspace& ws,

            Var::Vector out,

      const Var::Numeric start,

      const Var::Numeric stop) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorNLogSpace");

  }


  VectorNLogSpace(out.value(), Var::nelem(ws).value(), start.value(), stop.value(), Var::verbosity(ws).value());

}


inline void VectorReshapeMatrix(

            Workspace& ws,

            Var::Vector out,

      const Var::Matrix in,

      const Var::String direction=Group::String{"column"}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorReshapeMatrix");

  }


  VectorReshapeMatrix(out.value(), in.value(), direction.value(), Var::verbosity(ws).value());

}


inline void VectorScale(

            Workspace& ws,

            Var::Vector out,

      const Var::Vector in,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorScale");

  }


  VectorScale(out.value(), in.value(), value.value(), Var::verbosity(ws).value());

}


inline void VectorSetConstant(

            Workspace& ws,

            Var::Vector out,

      const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorSetConstant");

  }


  VectorSetConstant(out.value(), Var::nelem(ws).value(), value.value(), Var::verbosity(ws).value());

}


inline void VectorSet(

            Workspace& ws,

            Var::Vector out,

      const Var::Vector value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorSet");

  }


  VectorSet(out.value(), value.value(), Var::verbosity(ws).value());

}


inline void VectorSubtractVector(

            Workspace& ws,

            Var::Vector c,

      const Var::Vector a,

      const Var::Vector b) {

  if (c.islast()) {

    throw std::runtime_error("c needs to be a defined WorkspaceVector since it is output of VectorSubtractVector");

  }


  VectorSubtractVector(c.value(), a.value(), b.value(), Var::verbosity(ws).value());

}


inline void VectorVectorMultiply(

            Workspace& ws,

            Var::Vector out,

      const Var::Vector v1,

      const Var::Vector v2) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorVectorMultiply");

  }


  VectorVectorMultiply(out.value(), v1.value(), v2.value(), Var::verbosity(ws).value());

}


inline void VectorZtanToZaRefr1D(

            Workspace& ws,

            Var::Vector v_za,

      const Var::Vector v_ztan) {

  if (v_za.islast()) {

    throw std::runtime_error("v_za needs to be a defined WorkspaceVector since it is output of VectorZtanToZaRefr1D");

  }


  VectorZtanToZaRefr1D(ws, v_za.value(), Var::refr_index_air_agenda(ws).value(), Var::sensor_pos(ws).value(), Var::p_grid(ws).value(), Var::t_field(ws).value(), Var::z_field(ws).value(), Var::vmr_field(ws).value(), Var::refellipsoid(ws).value(), Var::atmosphere_dim(ws).value(), Var::f_grid(ws).value(), v_ztan.value(), Var::verbosity(ws).value());

}


inline void VectorZtanToZa1D(

            Workspace& ws,

            Var::Vector v_za,

      const Var::Vector v_ztan) {

  if (v_za.islast()) {

    throw std::runtime_error("v_za needs to be a defined WorkspaceVector since it is output of VectorZtanToZa1D");

  }


  VectorZtanToZa1D(v_za.value(), Var::sensor_pos(ws).value(), Var::refellipsoid(ws).value(), Var::atmosphere_dim(ws).value(), v_ztan.value(), Var::verbosity(ws).value());

}


inline void verbosityInit(

            Workspace& ws) {

  verbosityInit(Var::verbosity(ws).value());

}


inline void verbositySet(

            Workspace& ws,

      const Var::Index agenda,

      const Var::Index screen,

      const Var::Index file) {

  verbositySet(Var::verbosity(ws).value(), agenda.value(), screen.value(), file.value());

}


inline void verbositySetAgenda(

            Workspace& ws,

      const Var::Index level) {

  verbositySetAgenda(Var::verbosity(ws).value(), level.value());

}


inline void verbositySetFile(

            Workspace& ws,

      const Var::Index level) {

  verbositySetFile(Var::verbosity(ws).value(), level.value());

}


inline void verbositySetScreen(

            Workspace& ws,

      const Var::Index level) {

  verbositySetScreen(Var::verbosity(ws).value(), level.value());

}


inline void vmr_fieldClip(

            Workspace& ws,

      const Var::String species,

      const Var::Numeric limit_low=Group::Numeric{-std::numeric_limits<Numeric>::infinity()},

      const Var::Numeric limit_high=Group::Numeric{std::numeric_limits<Numeric>::infinity()}) {

  vmr_fieldClip(Var::vmr_field(ws).value(), Var::abs_species(ws).value(), species.value(), limit_low.value(), limit_high.value(), Var::verbosity(ws).value());

}


inline void vmr_fieldPerturb(

            Workspace& ws,

      const Var::String species,

      const Var::Vector p_ret_grid,

      const Var::Vector lat_ret_grid,

      const Var::Vector lon_ret_grid,

      const Var::Index pert_index,

      const Var::Numeric pert_size,

      const Var::String pert_mode=Group::String{"absolute"}) {

  vmr_fieldPerturb(Var::vmr_field(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::abs_species(ws).value(), species.value(), p_ret_grid.value(), lat_ret_grid.value(), lon_ret_grid.value(), pert_index.value(), pert_size.value(), pert_mode.value(), Var::verbosity(ws).value());

}


inline void vmr_fieldPerturbAtmGrids(

            Workspace& ws,

      const Var::String species,

      const Var::Index pert_index,

      const Var::Numeric pert_size,

      const Var::String pert_mode=Group::String{"absolute"}) {

  vmr_fieldPerturbAtmGrids(Var::vmr_field(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::abs_species(ws).value(), species.value(), pert_index.value(), pert_size.value(), pert_mode.value(), Var::verbosity(ws).value());

}


inline void vmr_fieldSetAllConstant(

            Workspace& ws,

      const Var::Vector vmr_values) {

  vmr_fieldSetAllConstant(Var::vmr_field(ws).value(), Var::abs_species(ws).value(), vmr_values.value(), Var::verbosity(ws).value());

}


inline void water_p_eq_fieldMK05(

            Workspace& ws) {

  water_p_eq_fieldMK05(Var::water_p_eq_field(ws).value(), Var::t_field(ws).value(), Var::verbosity(ws).value());

}


inline void vmr_fieldSetConstant(

            Workspace& ws,

      const Var::String species,

      const Var::Numeric vmr_value) {

  vmr_fieldSetConstant(Var::vmr_field(ws).value(), Var::abs_species(ws).value(), species.value(), vmr_value.value(), Var::verbosity(ws).value());

}


inline void Wigner6Init(

            Workspace& ws,

      const Var::Index fast_wigner_stored_symbols=Group::Index{20000000},

      const Var::Index largest_wigner_symbol_parameter=Group::Index{250}) {

  Wigner6Init(Var::wigner_initialized(ws).value(), fast_wigner_stored_symbols.value(), largest_wigner_symbol_parameter.value(), Var::verbosity(ws).value());

}


inline void Wigner3Init(

            Workspace& ws,

      const Var::Index fast_wigner_stored_symbols=Group::Index{20000000},

      const Var::Index largest_wigner_symbol_parameter=Group::Index{250}) {

  Wigner3Init(Var::wigner_initialized(ws).value(), fast_wigner_stored_symbols.value(), largest_wigner_symbol_parameter.value(), Var::verbosity(ws).value());

}


inline void Wigner6Unload(

            Workspace& ws) {

  Wigner6Unload(Var::wigner_initialized(ws).value(), Var::verbosity(ws).value());

}


inline void Wigner3Unload(

            Workspace& ws) {

  Wigner3Unload(Var::wigner_initialized(ws).value(), Var::verbosity(ws).value());

}


inline void WignerFastInfoPrint(

            Workspace& ws) {

  WignerFastInfoPrint(Var::wigner_initialized(ws).value(), Var::verbosity(ws).value());

}


inline void WindFieldsCalc(

            Workspace& ws,

      const Var::Index interp_order=Group::Index{1}) {

  WindFieldsCalc(Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::wind_u_field_raw(ws).value(), Var::wind_v_field_raw(ws).value(), Var::wind_w_field_raw(ws).value(), Var::atmosphere_dim(ws).value(), interp_order.value(), Var::verbosity(ws).value());

}


inline void WindFieldsCalcExpand1D(

            Workspace& ws,

      const Var::Index interp_order=Group::Index{1}) {

  WindFieldsCalcExpand1D(Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::wind_u_field_raw(ws).value(), Var::wind_v_field_raw(ws).value(), Var::wind_w_field_raw(ws).value(), Var::atmosphere_dim(ws).value(), interp_order.value(), Var::verbosity(ws).value());

}


inline void WindRawRead(

            Workspace& ws,

      const Var::String basename) {

  WindRawRead(Var::wind_u_field_raw(ws).value(), Var::wind_v_field_raw(ws).value(), Var::wind_w_field_raw(ws).value(), basename.value(), Var::verbosity(ws).value());

}


inline void wind_u_fieldIncludePlanetRotation(

            Workspace& ws) {

  wind_u_fieldIncludePlanetRotation(Var::wind_u_field(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::refellipsoid(ws).value(), Var::z_field(ws).value(), Var::planet_rotation_period(ws).value(), Var::verbosity(ws).value());

}


inline void WMRFSelectChannels(

            Workspace& ws) {

  WMRFSelectChannels(Var::f_grid(ws).value(), Var::wmrf_weights(ws).value(), Var::f_backend(ws).value(), Var::wmrf_channels(ws).value(), Var::verbosity(ws).value());

}


inline void WriteMolTau(

            Workspace& ws,

      const Var::String filename) {

  WriteMolTau(Var::f_grid(ws).value(), Var::z_field(ws).value(), Var::propmat_clearsky_field(ws).value(), Var::atmosphere_dim(ws).value(), filename.value(), Var::verbosity(ws).value());

}


inline void WriteNetCDF(

            Workspace& ws,

      const Var::Vector in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDF(in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDF(

            Workspace& ws,

      const Var::Matrix in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDF(in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDF(

            Workspace& ws,

      const Var::Tensor3 in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDF(in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDF(

            Workspace& ws,

      const Var::Tensor4 in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDF(in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDF(

            Workspace& ws,

      const Var::Tensor5 in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDF(in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDF(

            Workspace& ws,

      const Var::ArrayOfVector in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDF(in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDF(

            Workspace& ws,

      const Var::ArrayOfMatrix in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDF(in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDF(

            Workspace& ws,

      const Var::GasAbsLookup in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDF(in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDFIndexed(

            Workspace& ws,

      const Var::Vector in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDFIndexed(Var::file_index(ws).value(), in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDFIndexed(

            Workspace& ws,

      const Var::Matrix in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDFIndexed(Var::file_index(ws).value(), in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDFIndexed(

            Workspace& ws,

      const Var::Tensor3 in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDFIndexed(Var::file_index(ws).value(), in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDFIndexed(

            Workspace& ws,

      const Var::Tensor4 in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDFIndexed(Var::file_index(ws).value(), in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDFIndexed(

            Workspace& ws,

      const Var::Tensor5 in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDFIndexed(Var::file_index(ws).value(), in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDFIndexed(

            Workspace& ws,

      const Var::ArrayOfVector in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDFIndexed(Var::file_index(ws).value(), in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDFIndexed(

            Workspace& ws,

      const Var::ArrayOfMatrix in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDFIndexed(Var::file_index(ws).value(), in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteNetCDFIndexed(

            Workspace& ws,

      const Var::GasAbsLookup in,

      const Var::String filename=Group::String{""}) {

  WriteNetCDFIndexed(Var::file_index(ws).value(), in.value(), filename.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::AbsorptionLines in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Agenda in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(ws, Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfAbsorptionLines in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfAbsorptionLines in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfAgenda in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(ws, Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField1 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField2 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField3 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfIndex in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfPpath in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfPropagationMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfRadiationVector in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfScatteringMetaData in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfSingleScatteringData in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfSpeciesTag in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfStokesVector in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfString in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor3 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor6 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfTime in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfTransmissionMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfArrayOfVector in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfCIARecord in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfGriddedField1 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfGriddedField2 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfGriddedField3 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfGriddedField4 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfIndex in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfPropagationMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfRadiationVector in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfRetrievalQuantity in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfScatteringMetaData in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfSingleScatteringData in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfSparse in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfStokesVector in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfString in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfTelsemAtlas in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfTensor3 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfTensor4 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfTensor5 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfTensor6 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfTensor7 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfTime in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfTransmissionMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfVector in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ArrayOfXsecRecord in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::CIARecord in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::CovarianceMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::EnergyLevelMap in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::GasAbsLookup in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::GridPos in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::GriddedField1 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::GriddedField2 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::GriddedField3 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::GriddedField4 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::GriddedField5 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::GriddedField6 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::HitranRelaxationMatrixData in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Index in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::MCAntenna in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Matrix in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Numeric in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Ppath in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::PropagationMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::QuantumIdentifier in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::RadiationVector in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Rational in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::ScatteringMetaData in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::SingleScatteringData in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Sparse in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::SpeciesAuxData in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::StokesVector in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::String in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::TelsemAtlas in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Tensor3 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Tensor4 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Tensor5 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Tensor6 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Tensor7 in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Timer in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Time in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::TessemNN in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::TransmissionMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Vector in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXML(

            Workspace& ws,

      const Var::Verbosity in,

      const Var::String filename=Group::String{""},

      const Var::Index no_clobber=Group::Index{0}) {

  WriteXML(Var::output_file_format(ws).value(), in.value(), filename.value(), no_clobber.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), no_clobber.islast() ? Group::String{"no_clobber"} : no_clobber.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::AbsorptionLines in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Agenda in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(ws, Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfAbsorptionLines in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfAbsorptionLines in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfAgenda in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(ws, Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField1 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField2 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfGriddedField3 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfIndex in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfPpath in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfPropagationMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfRadiationVector in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfScatteringMetaData in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfSingleScatteringData in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfSpeciesTag in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfStokesVector in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfString in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor3 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfTensor6 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfTime in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfTransmissionMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfArrayOfVector in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfCIARecord in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfGriddedField1 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfGriddedField2 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfGriddedField3 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfGriddedField4 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfIndex in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfPropagationMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfQuantumIdentifier in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfRadiationVector in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfRetrievalQuantity in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfScatteringMetaData in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfSingleScatteringData in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfSparse in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfStokesVector in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfString in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfTelsemAtlas in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfTensor3 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfTensor4 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfTensor5 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfTensor6 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfTensor7 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfTime in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfTransmissionMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfVector in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ArrayOfXsecRecord in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::CIARecord in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::CovarianceMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::EnergyLevelMap in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::GasAbsLookup in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::GridPos in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::GriddedField1 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::GriddedField2 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::GriddedField3 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::GriddedField4 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::GriddedField5 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::GriddedField6 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::HitranRelaxationMatrixData in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Index in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::MCAntenna in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Matrix in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Numeric in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Ppath in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::PropagationMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::QuantumIdentifier in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::RadiationVector in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Rational in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::ScatteringMetaData in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::SingleScatteringData in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Sparse in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::SpeciesAuxData in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::StokesVector in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::String in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::TelsemAtlas in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Tensor3 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Tensor4 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Tensor5 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Tensor6 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Tensor7 in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Timer in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Time in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::TessemNN in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::TransmissionMatrix in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Vector in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void WriteXMLIndexed(

            Workspace& ws,

      const Var::Verbosity in,

      const Var::String filename=Group::String{""},

      const Var::Index digits=Group::Index{0}) {

  WriteXMLIndexed(Var::output_file_format(ws).value(), Var::file_index(ws).value(), in.value(), filename.value(), digits.value(), in.islast() ? Group::String{"in"} : in.name(), filename.islast() ? Group::String{"filename"} : filename.name(), digits.islast() ? Group::String{"digits"} : digits.name(), Var::verbosity(ws).value());

}


inline void xaStandard(

            Workspace& ws) {

  xaStandard(ws, Var::xa(ws).value(), Var::jacobian_quantities(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::t_field(ws).value(), Var::vmr_field(ws).value(), Var::abs_species(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_checked(ws).value(), Var::particle_bulkprop_field(ws).value(), Var::particle_bulkprop_names(ws).value(), Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::surface_props_data(ws).value(), Var::surface_props_names(ws).value(), Var::water_p_eq_agenda(ws).value(), Var::verbosity(ws).value());

}


inline void xClip(

            Workspace& ws,

      const Var::Index ijq,

      const Var::Numeric limit_low=Group::Numeric{-std::numeric_limits<Numeric>::infinity()},

      const Var::Numeric limit_high=Group::Numeric{std::numeric_limits<Numeric>::infinity()}) {

  xClip(Var::x(ws).value(), Var::jacobian_quantities(ws).value(), ijq.value(), limit_low.value(), limit_high.value(), Var::verbosity(ws).value());

}


inline void x2artsAtmAndSurf(

            Workspace& ws) {

  x2artsAtmAndSurf(ws, Var::vmr_field(ws).value(), Var::t_field(ws).value(), Var::particle_bulkprop_field(ws).value(), Var::wind_u_field(ws).value(), Var::wind_v_field(ws).value(), Var::wind_w_field(ws).value(), Var::mag_u_field(ws).value(), Var::mag_v_field(ws).value(), Var::mag_w_field(ws).value(), Var::surface_props_data(ws).value(), Var::jacobian_quantities(ws).value(), Var::x(ws).value(), Var::atmfields_checked(ws).value(), Var::atmgeom_checked(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::abs_species(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_checked(ws).value(), Var::particle_bulkprop_names(ws).value(), Var::surface_props_names(ws).value(), Var::water_p_eq_agenda(ws).value(), Var::verbosity(ws).value());

}


inline void x2artsSensor(

            Workspace& ws) {

  x2artsSensor(ws, Var::sensor_los(ws).value(), Var::f_backend(ws).value(), Var::y_baseline(ws).value(), Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::sensor_response_f_grid(ws).value(), Var::sensor_response_pol_grid(ws).value(), Var::sensor_response_dlos_grid(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::jacobian_quantities(ws).value(), Var::x(ws).value(), Var::sensor_response_agenda(ws).value(), Var::sensor_checked(ws).value(), Var::sensor_time(ws).value(), Var::verbosity(ws).value());

}


inline void x2artsSpectroscopy(

            Workspace& ws) {

  x2artsSpectroscopy(Var::verbosity(ws).value());

}


inline void yApplySensorPol(

            Workspace& ws) {

  yApplySensorPol(Var::y(ws).value(), Var::y_f(ws).value(), Var::y_pol(ws).value(), Var::y_pos(ws).value(), Var::y_los(ws).value(), Var::y_aux(ws).value(), Var::y_geo(ws).value(), Var::jacobian(ws).value(), Var::stokes_dim(ws).value(), Var::jacobian_do(ws).value(), Var::sensor_pos(ws).value(), Var::sensor_pol(ws).value(), Var::verbosity(ws).value());

}


inline void yApplyUnit(

            Workspace& ws) {

  yApplyUnit(Var::y(ws).value(), Var::jacobian(ws).value(), Var::y_f(ws).value(), Var::y_pol(ws).value(), Var::iy_unit(ws).value(), Var::verbosity(ws).value());

}


inline void ybatchCalc(

            Workspace& ws,

      const Var::Index robust=Group::Index{0}) {

  ybatchCalc(ws, Var::ybatch(ws).value(), Var::ybatch_aux(ws).value(), Var::ybatch_jacobians(ws).value(), Var::ybatch_start(ws).value(), Var::ybatch_n(ws).value(), Var::ybatch_calc_agenda(ws).value(), robust.value(), Var::verbosity(ws).value());

}


inline void yColdAtmHot(

            Workspace& ws,

      const Var::Vector cold,

      const Var::Vector atm,

      const Var::Vector hot,

      const Var::Numeric cold_temp,

      const Var::Numeric hot_temp,

      const Var::Index calib=Group::Index{1}) {

  yColdAtmHot(Var::y(ws).value(), cold.value(), atm.value(), hot.value(), cold_temp.value(), hot_temp.value(), calib.value(), Var::verbosity(ws).value());

}


inline void ybatchMetProfiles(

            Workspace& ws,

      const Var::Index nelem_p_grid,

      const Var::String met_profile_path,

      const Var::String met_profile_pnd_path) {

  ybatchMetProfiles(ws, Var::ybatch(ws).value(), Var::abs_species(ws).value(), Var::met_profile_calc_agenda(ws).value(), Var::f_grid(ws).value(), Var::met_amsu_data(ws).value(), Var::sensor_pos(ws).value(), Var::refellipsoid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::scat_data(ws).value(), nelem_p_grid.value(), met_profile_path.value(), met_profile_pnd_path.value(), Var::verbosity(ws).value());

}


inline void ybatchMetProfilesClear(

            Workspace& ws,

      const Var::Index nelem_p_grid,

      const Var::String met_profile_path) {

  ybatchMetProfilesClear(ws, Var::ybatch(ws).value(), Var::abs_species(ws).value(), Var::met_profile_calc_agenda(ws).value(), Var::f_grid(ws).value(), Var::met_amsu_data(ws).value(), Var::sensor_pos(ws).value(), Var::refellipsoid(ws).value(), nelem_p_grid.value(), met_profile_path.value(), Var::verbosity(ws).value());

}


inline void ybatchTimeAveraging(

            Workspace& ws,

      const Var::String time_step,

      const Var::Index disregard_first=Group::Index{0},

      const Var::Index disregard_last=Group::Index{0}) {

  ybatchTimeAveraging(Var::ybatch(ws).value(), Var::time_grid(ws).value(), Var::covmat_sepsbatch(ws).value(), Var::counts(ws).value(), time_step.value(), disregard_first.value(), disregard_last.value(), Var::verbosity(ws).value());

}


inline void ybatchTroposphericCorrectionNaiveMedianForward(

            Workspace& ws,

      const Var::ArrayOfIndex range,

      const Var::Vector trop_temp,

      const Var::Numeric targ_temp=Group::Numeric{2.73}) {

  ybatchTroposphericCorrectionNaiveMedianForward(Var::ybatch_corr(ws).value(), Var::ybatch(ws).value(), range.value(), trop_temp.value(), targ_temp.value(), Var::verbosity(ws).value());

}


inline void ybatchTroposphericCorrectionNaiveMedianInverse(

            Workspace& ws) {

  ybatchTroposphericCorrectionNaiveMedianInverse(Var::ybatch(ws).value(), Var::ybatch_corr(ws).value(), Var::verbosity(ws).value());

}


inline void yCalc(

            Workspace& ws) {

  yCalc(ws, Var::y(ws).value(), Var::y_f(ws).value(), Var::y_pol(ws).value(), Var::y_pos(ws).value(), Var::y_los(ws).value(), Var::y_aux(ws).value(), Var::y_geo(ws).value(), Var::jacobian(ws).value(), Var::atmgeom_checked(ws).value(), Var::atmfields_checked(ws).value(), Var::atmosphere_dim(ws).value(), Var::nlte_field(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_checked(ws).value(), Var::scat_data_checked(ws).value(), Var::sensor_checked(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::sensor_pos(ws).value(), Var::sensor_los(ws).value(), Var::transmitter_pos(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::iy_unit(ws).value(), Var::iy_main_agenda(ws).value(), Var::geo_pos_agenda(ws).value(), Var::jacobian_agenda(ws).value(), Var::jacobian_do(ws).value(), Var::jacobian_quantities(ws).value(), Var::iy_aux_vars(ws).value(), Var::verbosity(ws).value());

}


inline void yCalcAppend(

            Workspace& ws,

      const Var::ArrayOfRetrievalQuantity jacobian_quantities_copy,

      const Var::Index append_instrument_wfs=Group::Index{0}) {

  yCalcAppend(ws, Var::y(ws).value(), Var::y_f(ws).value(), Var::y_pol(ws).value(), Var::y_pos(ws).value(), Var::y_los(ws).value(), Var::y_aux(ws).value(), Var::y_geo(ws).value(), Var::jacobian(ws).value(), Var::jacobian_quantities(ws).value(), Var::atmgeom_checked(ws).value(), Var::atmfields_checked(ws).value(), Var::atmosphere_dim(ws).value(), Var::nlte_field(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_checked(ws).value(), Var::scat_data_checked(ws).value(), Var::sensor_checked(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::sensor_pos(ws).value(), Var::sensor_los(ws).value(), Var::transmitter_pos(ws).value(), Var::mblock_dlos_grid(ws).value(), Var::sensor_response(ws).value(), Var::sensor_response_f(ws).value(), Var::sensor_response_pol(ws).value(), Var::sensor_response_dlos(ws).value(), Var::iy_unit(ws).value(), Var::iy_main_agenda(ws).value(), Var::geo_pos_agenda(ws).value(), Var::jacobian_agenda(ws).value(), Var::jacobian_do(ws).value(), Var::iy_aux_vars(ws).value(), jacobian_quantities_copy.value(), append_instrument_wfs.value(), Var::verbosity(ws).value());

}


inline void yActive(

            Workspace& ws,

      const Var::Numeric ze_tref=Group::Numeric{273.15},

      const Var::Numeric k2=Group::Numeric{-1},

      const Var::Numeric dbze_min=Group::Numeric{-99}) {

  yActive(ws, Var::y(ws).value(), Var::y_f(ws).value(), Var::y_pol(ws).value(), Var::y_pos(ws).value(), Var::y_los(ws).value(), Var::y_aux(ws).value(), Var::y_geo(ws).value(), Var::jacobian(ws).value(), Var::atmgeom_checked(ws).value(), Var::atmfields_checked(ws).value(), Var::iy_unit(ws).value(), Var::iy_aux_vars(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), Var::atmosphere_dim(ws).value(), Var::nlte_field(ws).value(), Var::cloudbox_on(ws).value(), Var::cloudbox_checked(ws).value(), Var::sensor_pos(ws).value(), Var::sensor_los(ws).value(), Var::sensor_checked(ws).value(), Var::jacobian_do(ws).value(), Var::jacobian_quantities(ws).value(), Var::iy_main_agenda(ws).value(), Var::geo_pos_agenda(ws).value(), Var::instrument_pol_array(ws).value(), Var::range_bins(ws).value(), ze_tref.value(), k2.value(), dbze_min.value(), Var::verbosity(ws).value());

}


inline void ySimpleSpectrometer(

            Workspace& ws,

      const Var::Numeric df) {

  ySimpleSpectrometer(Var::y(ws).value(), Var::y_f(ws).value(), Var::iy(ws).value(), Var::stokes_dim(ws).value(), Var::f_grid(ws).value(), df.value(), Var::verbosity(ws).value());

}


inline void z_fieldFromHSE(

            Workspace& ws) {

  z_fieldFromHSE(ws, Var::z_field(ws).value(), Var::atmosphere_dim(ws).value(), Var::p_grid(ws).value(), Var::lat_grid(ws).value(), Var::lon_grid(ws).value(), Var::lat_true(ws).value(), Var::lon_true(ws).value(), Var::abs_species(ws).value(), Var::t_field(ws).value(), Var::vmr_field(ws).value(), Var::refellipsoid(ws).value(), Var::z_surface(ws).value(), Var::atmfields_checked(ws).value(), Var::g0_agenda(ws).value(), Var::molarmass_dry_air(ws).value(), Var::p_hse(ws).value(), Var::z_hse_accuracy(ws).value(), Var::verbosity(ws).value());

}


}  // ARTS::Method


namespace ARTS::AgendaMethod  {

[[nodiscard]] inline

MRecord AbsInputFromAtmFields(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(88,

    Group::ArrayOfIndex({20, 23, 27, }),

    Group::ArrayOfIndex({35, 242, 338, 344, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AbsInputFromRteScalars(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(89,

    Group::ArrayOfIndex({20, 23, 27, }),

    Group::ArrayOfIndex({263, 264, 266, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_cia_dataAddCIARecord(

    [[maybe_unused]] Workspace& ws,

               const Var::CIARecord cia_record,

               const Var::Index& clobber={}) {

  if (cia_record.islast()) {

    throw std::runtime_error("cia_record needs to be a defined WorkspaceCIARecord since it is agenda input to abs_cia_dataAddCIARecord");

  } if (not clobber.isnull() and clobber.islast()) {

    throw std::runtime_error("clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_cia_dataAddCIARecord");

  }


  static const auto clobber_default = Var::IndexCreate(ws, 0,

    "abs_cia_dataAddCIARecord_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(90,

    Group::ArrayOfIndex({2, }),

    Group::ArrayOfIndex({Group::Index(cia_record.pos()), clobber.isnull() ? Index(clobber_default.pos()) : Group::Index(clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_cia_dataReadFromCIA(

    [[maybe_unused]] Workspace& ws,

               const Var::String catalogpath) {

  if (catalogpath.islast()) {

    throw std::runtime_error("catalogpath needs to be a defined WorkspaceString since it is agenda input to abs_cia_dataReadFromCIA");

  }


  return MRecord(91,

    Group::ArrayOfIndex({2, }),

    Group::ArrayOfIndex({21, Group::Index(catalogpath.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_cia_dataReadFromXML(

    [[maybe_unused]] Workspace& ws,

               const Var::String& filename={}) {

  if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to abs_cia_dataReadFromXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "abs_cia_dataReadFromXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(92,

    Group::ArrayOfIndex({2, }),

    Group::ArrayOfIndex({21, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_coefCalcFromXsec(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(93,

    Group::ArrayOfIndex({3, 308, 63, 70, 4, 309, }),

    Group::ArrayOfIndex({30, 307, 64, 71, 21, 137, 27, 20, 23, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_cont_descriptionAppend(

    [[maybe_unused]] Workspace& ws,

               const Var::String tagname,

               const Var::String model,

               const Var::Vector& userparam={}) {

  if (tagname.islast()) {

    throw std::runtime_error("tagname needs to be a defined WorkspaceString since it is agenda input to abs_cont_descriptionAppend");

  } if (model.islast()) {

    throw std::runtime_error("model needs to be a defined WorkspaceString since it is agenda input to abs_cont_descriptionAppend");

  } if (not userparam.isnull() and userparam.islast()) {

    throw std::runtime_error("userparam needs to be a defined WorkspaceVector (or left default) since it is agenda input to abs_cont_descriptionAppend");

  }


  static const auto userparam_default = Var::VectorCreate(ws, {},

    "abs_cont_descriptionAppend_userparam_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(94,

    Group::ArrayOfIndex({6, 5, 7, }),

    Group::ArrayOfIndex({Group::Index(tagname.pos()), Group::Index(model.pos()), userparam.isnull() ? Index(userparam_default.pos()) : Group::Index(userparam.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_cont_descriptionInit(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(95,

    Group::ArrayOfIndex({6, 5, 7, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_hitran_relmat_dataReadHitranRelmatDataAndLines(

    [[maybe_unused]] Workspace& ws,

               const Var::String basedir,

               const Var::Numeric& linemixinglimit={},

               const Var::Numeric& fmin={},

               const Var::Numeric& fmax={},

               const Var::Numeric& stot={},

               const Var::String& mode={}) {

  if (basedir.islast()) {

    throw std::runtime_error("basedir needs to be a defined WorkspaceString since it is agenda input to abs_hitran_relmat_dataReadHitranRelmatDataAndLines");

  } if (not linemixinglimit.isnull() and linemixinglimit.islast()) {

    throw std::runtime_error("linemixinglimit needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_hitran_relmat_dataReadHitranRelmatDataAndLines");

  } if (not fmin.isnull() and fmin.islast()) {

    throw std::runtime_error("fmin needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_hitran_relmat_dataReadHitranRelmatDataAndLines");

  } if (not fmax.isnull() and fmax.islast()) {

    throw std::runtime_error("fmax needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_hitran_relmat_dataReadHitranRelmatDataAndLines");

  } if (not stot.isnull() and stot.islast()) {

    throw std::runtime_error("stot needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_hitran_relmat_dataReadHitranRelmatDataAndLines");

  } if (not mode.isnull() and mode.islast()) {

    throw std::runtime_error("mode needs to be a defined WorkspaceString (or left default) since it is agenda input to abs_hitran_relmat_dataReadHitranRelmatDataAndLines");

  }


  static const auto linemixinglimit_default = Var::NumericCreate(ws, -1,

    "abs_hitran_relmat_dataReadHitranRelmatDataAndLines_linemixinglimit_autodefault",

    "auto generated variable with default from method definition");

  static const auto fmin_default = Var::NumericCreate(ws, 0,

    "abs_hitran_relmat_dataReadHitranRelmatDataAndLines_fmin_autodefault",

    "auto generated variable with default from method definition");

  static const auto fmax_default = Var::NumericCreate(ws, 1e99,

    "abs_hitran_relmat_dataReadHitranRelmatDataAndLines_fmax_autodefault",

    "auto generated variable with default from method definition");

  static const auto stot_default = Var::NumericCreate(ws, 0,

    "abs_hitran_relmat_dataReadHitranRelmatDataAndLines_stot_autodefault",

    "auto generated variable with default from method definition");

  static const auto mode_default = Var::StringCreate(ws, "VP_W",

    "abs_hitran_relmat_dataReadHitranRelmatDataAndLines_mode_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(96,

    Group::ArrayOfIndex({9, 11, }),

    Group::ArrayOfIndex({21, Group::Index(basedir.pos()), linemixinglimit.isnull() ? Index(linemixinglimit_default.pos()) : Group::Index(linemixinglimit.pos()), fmin.isnull() ? Index(fmin_default.pos()) : Group::Index(fmin.pos()), fmax.isnull() ? Index(fmax_default.pos()) : Group::Index(fmax.pos()), stot.isnull() ? Index(stot_default.pos()) : Group::Index(stot.pos()), mode.isnull() ? Index(mode_default.pos()) : Group::Index(mode.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesCleanupEmpty(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(97,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesKeepBands(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier qid,

               const Var::Index& ignore_spec={},

               const Var::Index& ignore_isot={}) {

  if (qid.islast()) {

    throw std::runtime_error("qid needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesKeepBands");

  } if (not ignore_spec.isnull() and ignore_spec.islast()) {

    throw std::runtime_error("ignore_spec needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_linesKeepBands");

  } if (not ignore_isot.isnull() and ignore_isot.islast()) {

    throw std::runtime_error("ignore_isot needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_linesKeepBands");

  }


  static const auto ignore_spec_default = Var::IndexCreate(ws, 1,

    "abs_linesKeepBands_ignore_spec_autodefault",

    "auto generated variable with default from method definition");

  static const auto ignore_isot_default = Var::IndexCreate(ws, 1,

    "abs_linesKeepBands_ignore_isot_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(98,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(qid.pos()), ignore_spec.isnull() ? Index(ignore_spec_default.pos()) : Group::Index(ignore_spec.pos()), ignore_isot.isnull() ? Index(ignore_isot_default.pos()) : Group::Index(ignore_isot.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesRemoveBand(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier qid) {

  if (qid.islast()) {

    throw std::runtime_error("qid needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesRemoveBand");

  }


  return MRecord(99,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(qid.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesRemoveUnusedLocalQuantumNumbers(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(100,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesReplaceWithLines(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAbsorptionLines replacing_lines) {

  if (replacing_lines.islast()) {

    throw std::runtime_error("replacing_lines needs to be a defined WorkspaceArrayOfAbsorptionLines since it is agenda input to abs_linesReplaceWithLines");

  }


  return MRecord(101,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(replacing_lines.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesAppendWithLines(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAbsorptionLines appending_lines,

               const Var::Index& safe={}) {

  if (appending_lines.islast()) {

    throw std::runtime_error("appending_lines needs to be a defined WorkspaceArrayOfAbsorptionLines since it is agenda input to abs_linesAppendWithLines");

  } if (not safe.isnull() and safe.islast()) {

    throw std::runtime_error("safe needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_linesAppendWithLines");

  }


  static const auto safe_default = Var::IndexCreate(ws, 1,

    "abs_linesAppendWithLines_safe_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(102,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(appending_lines.pos()), safe.isnull() ? Index(safe_default.pos()) : Group::Index(safe.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesDeleteWithLines(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAbsorptionLines deleting_lines) {

  if (deleting_lines.islast()) {

    throw std::runtime_error("deleting_lines needs to be a defined WorkspaceArrayOfAbsorptionLines since it is agenda input to abs_linesDeleteWithLines");

  }


  return MRecord(103,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(deleting_lines.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesDeleteBadF0(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric f0,

               const Var::Index& lower={}) {

  if (f0.islast()) {

    throw std::runtime_error("f0 needs to be a defined WorkspaceNumeric since it is agenda input to abs_linesDeleteBadF0");

  } if (not lower.isnull() and lower.islast()) {

    throw std::runtime_error("lower needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_linesDeleteBadF0");

  }


  static const auto lower_default = Var::IndexCreate(ws, 1,

    "abs_linesDeleteBadF0_lower_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(104,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(f0.pos()), lower.isnull() ? Index(lower_default.pos()) : Group::Index(lower.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesDeleteLinesWithUndefinedLocalQuanta(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(105,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesDeleteLinesWithBadOrHighChangingJs(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(106,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesDeleteLinesWithQuantumNumberAbove(

    [[maybe_unused]] Workspace& ws,

               const Var::String quantumnumber,

               const Var::Index quantumnumber_value) {

  if (quantumnumber.islast()) {

    throw std::runtime_error("quantumnumber needs to be a defined WorkspaceString since it is agenda input to abs_linesDeleteLinesWithQuantumNumberAbove");

  } if (quantumnumber_value.islast()) {

    throw std::runtime_error("quantumnumber_value needs to be a defined WorkspaceIndex since it is agenda input to abs_linesDeleteLinesWithQuantumNumberAbove");

  }


  return MRecord(107,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(quantumnumber.pos()), Group::Index(quantumnumber_value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesPrintDefinedQuantumNumbers(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(108,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({10, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesReadSplitCatalog(

    [[maybe_unused]] Workspace& ws,

               const Var::String basename) {

  if (basename.islast()) {

    throw std::runtime_error("basename needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesReadSplitCatalog");

  }


  return MRecord(109,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({21, Group::Index(basename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesReadSpeciesSplitCatalog(

    [[maybe_unused]] Workspace& ws,

               const Var::String basename,

               const Var::Index& robust={}) {

  if (basename.islast()) {

    throw std::runtime_error("basename needs to be a defined WorkspaceString since it is agenda input to abs_linesReadSpeciesSplitCatalog");

  } if (not robust.isnull() and robust.islast()) {

    throw std::runtime_error("robust needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_linesReadSpeciesSplitCatalog");

  }


  static const auto robust_default = Var::IndexCreate(ws, 0,

    "abs_linesReadSpeciesSplitCatalog_robust_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(110,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(basename.pos()), robust.isnull() ? Index(robust_default.pos()) : Group::Index(robust.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesReadSpeciesSplitCatalog(

    [[maybe_unused]] Workspace& ws,

               const Var::String basename,

               const Var::Index& robust={}) {

  if (basename.islast()) {

    throw std::runtime_error("basename needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesReadSpeciesSplitCatalog");

  } if (not robust.isnull() and robust.islast()) {

    throw std::runtime_error("robust needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_lines_per_speciesReadSpeciesSplitCatalog");

  }


  static const auto robust_default = Var::IndexCreate(ws, 0,

    "abs_lines_per_speciesReadSpeciesSplitCatalog_robust_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(111,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({21, Group::Index(basename.pos()), robust.isnull() ? Index(robust_default.pos()) : Group::Index(robust.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetEmpty(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(112,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({21, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetEmptyBroadeningParametersToEmpty(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(113,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetNormalization(

    [[maybe_unused]] Workspace& ws,

               const Var::String option) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_linesSetNormalization");

  }


  return MRecord(114,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetNormalization(

    [[maybe_unused]] Workspace& ws,

               const Var::String option) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetNormalization");

  }


  return MRecord(115,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetNormalizationForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::QuantumIdentifier ID) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_linesSetNormalizationForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesSetNormalizationForMatch");

  }


  return MRecord(116,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetNormalizationForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::QuantumIdentifier ID) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetNormalizationForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetNormalizationForMatch");

  }


  return MRecord(117,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetNormalizationForSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::String species_tag) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetNormalizationForSpecies");

  } if (species_tag.islast()) {

    throw std::runtime_error("species_tag needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetNormalizationForSpecies");

  }


  return MRecord(118,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({21, Group::Index(option.pos()), Group::Index(species_tag.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetMirroring(

    [[maybe_unused]] Workspace& ws,

               const Var::String option) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_linesSetMirroring");

  }


  return MRecord(119,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetMirroring(

    [[maybe_unused]] Workspace& ws,

               const Var::String option) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetMirroring");

  }


  return MRecord(120,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetMirroringForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::QuantumIdentifier ID) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_linesSetMirroringForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesSetMirroringForMatch");

  }


  return MRecord(121,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetMirroringForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::QuantumIdentifier ID) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetMirroringForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetMirroringForMatch");

  }


  return MRecord(122,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetMirroringForSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::String species_tag) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetMirroringForSpecies");

  } if (species_tag.islast()) {

    throw std::runtime_error("species_tag needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetMirroringForSpecies");

  }


  return MRecord(123,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({21, Group::Index(option.pos()), Group::Index(species_tag.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetPopulation(

    [[maybe_unused]] Workspace& ws,

               const Var::String option) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_linesSetPopulation");

  }


  return MRecord(124,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetPopulation(

    [[maybe_unused]] Workspace& ws,

               const Var::String option) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetPopulation");

  }


  return MRecord(125,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetPopulationForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::QuantumIdentifier ID) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_linesSetPopulationForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesSetPopulationForMatch");

  }


  return MRecord(126,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetPopulationForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::QuantumIdentifier ID) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetPopulationForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetPopulationForMatch");

  }


  return MRecord(127,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetPopulationForSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::String species_tag) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetPopulationForSpecies");

  } if (species_tag.islast()) {

    throw std::runtime_error("species_tag needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetPopulationForSpecies");

  }


  return MRecord(128,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({21, Group::Index(option.pos()), Group::Index(species_tag.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetLineShapeType(

    [[maybe_unused]] Workspace& ws,

               const Var::String option) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_linesSetLineShapeType");

  }


  return MRecord(129,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetLineShapeType(

    [[maybe_unused]] Workspace& ws,

               const Var::String option) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetLineShapeType");

  }


  return MRecord(130,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetLineShapeTypeForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::QuantumIdentifier ID) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_linesSetLineShapeTypeForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesSetLineShapeTypeForMatch");

  }


  return MRecord(131,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetLineShapeTypeForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::QuantumIdentifier ID) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetLineShapeTypeForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetLineShapeTypeForMatch");

  }


  return MRecord(132,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetLineShapeTypeForSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::String species_tag) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetLineShapeTypeForSpecies");

  } if (species_tag.islast()) {

    throw std::runtime_error("species_tag needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetLineShapeTypeForSpecies");

  }


  return MRecord(133,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({21, Group::Index(option.pos()), Group::Index(species_tag.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetCutoff(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::Numeric value) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_linesSetCutoff");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_linesSetCutoff");

  }


  return MRecord(134,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetCutoff(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::Numeric value) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetCutoff");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesSetCutoff");

  }


  return MRecord(135,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetCutoffForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::Numeric value,

               const Var::QuantumIdentifier ID) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_linesSetCutoffForMatch");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_linesSetCutoffForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesSetCutoffForMatch");

  }


  return MRecord(136,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), Group::Index(value.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetCutoffForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::Numeric value,

               const Var::QuantumIdentifier ID) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetCutoffForMatch");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesSetCutoffForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetCutoffForMatch");

  }


  return MRecord(137,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(option.pos()), Group::Index(value.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetCutoffForSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::String option,

               const Var::Numeric value,

               const Var::String species_tag) {

  if (option.islast()) {

    throw std::runtime_error("option needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetCutoffForSpecies");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesSetCutoffForSpecies");

  } if (species_tag.islast()) {

    throw std::runtime_error("species_tag needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetCutoffForSpecies");

  }


  return MRecord(138,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({21, Group::Index(option.pos()), Group::Index(value.pos()), Group::Index(species_tag.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetLinemixingLimit(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric value) {

  if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_linesSetLinemixingLimit");

  }


  return MRecord(139,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetLinemixingLimit(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric value) {

  if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesSetLinemixingLimit");

  }


  return MRecord(140,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetLinemixingLimitForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric value,

               const Var::QuantumIdentifier ID) {

  if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_linesSetLinemixingLimitForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesSetLinemixingLimitForMatch");

  }


  return MRecord(141,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(value.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetLinemixingLimitForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric value,

               const Var::QuantumIdentifier ID) {

  if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesSetLinemixingLimitForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetLinemixingLimitForMatch");

  }


  return MRecord(142,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(value.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetLinemixingLimitForSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric value,

               const Var::String species_tag) {

  if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesSetLinemixingLimitForSpecies");

  } if (species_tag.islast()) {

    throw std::runtime_error("species_tag needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetLinemixingLimitForSpecies");

  }


  return MRecord(143,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({21, Group::Index(value.pos()), Group::Index(species_tag.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetT0(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric value) {

  if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_linesSetT0");

  }


  return MRecord(144,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetT0(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric value) {

  if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesSetT0");

  }


  return MRecord(145,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetT0ForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric value,

               const Var::QuantumIdentifier ID) {

  if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_linesSetT0ForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesSetT0ForMatch");

  }


  return MRecord(146,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(value.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetT0ForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric value,

               const Var::QuantumIdentifier ID) {

  if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesSetT0ForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetT0ForMatch");

  }


  return MRecord(147,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(value.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetT0ForSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric value,

               const Var::String species_tag) {

  if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesSetT0ForSpecies");

  } if (species_tag.islast()) {

    throw std::runtime_error("species_tag needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetT0ForSpecies");

  }


  return MRecord(148,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({21, Group::Index(value.pos()), Group::Index(species_tag.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetQuantumNumberForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::String quantum_number,

               const Var::Rational value,

               const Var::QuantumIdentifier ID) {

  if (quantum_number.islast()) {

    throw std::runtime_error("quantum_number needs to be a defined WorkspaceString since it is agenda input to abs_linesSetQuantumNumberForMatch");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceRational since it is agenda input to abs_linesSetQuantumNumberForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesSetQuantumNumberForMatch");

  }


  return MRecord(149,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(quantum_number.pos()), Group::Index(value.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetQuantumNumberForMatch(

    [[maybe_unused]] Workspace& ws,

               const Var::String quantum_number,

               const Var::Rational value,

               const Var::QuantumIdentifier ID) {

  if (quantum_number.islast()) {

    throw std::runtime_error("quantum_number needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetQuantumNumberForMatch");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceRational since it is agenda input to abs_lines_per_speciesSetQuantumNumberForMatch");

  } if (ID.islast()) {

    throw std::runtime_error("ID needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetQuantumNumberForMatch");

  }


  return MRecord(150,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(quantum_number.pos()), Group::Index(value.pos()), Group::Index(ID.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesChangeBaseParameterForMatchingLevel(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter_name,

               const Var::Numeric change,

               const Var::Index& relative={}) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesChangeBaseParameterForMatchingLevel");

  } if (parameter_name.islast()) {

    throw std::runtime_error("parameter_name needs to be a defined WorkspaceString since it is agenda input to abs_linesChangeBaseParameterForMatchingLevel");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_linesChangeBaseParameterForMatchingLevel");

  } if (not relative.isnull() and relative.islast()) {

    throw std::runtime_error("relative needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_linesChangeBaseParameterForMatchingLevel");

  }


  static const auto relative_default = Var::IndexCreate(ws, 0,

    "abs_linesChangeBaseParameterForMatchingLevel_relative_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(151,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter_name.pos()), Group::Index(change.pos()), relative.isnull() ? Index(relative_default.pos()) : Group::Index(relative.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesChangeBaseParameterForMatchingLevels(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier QI,

               const Var::String parameter_name,

               const Var::Vector change,

               const Var::Index& relative={}) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to abs_linesChangeBaseParameterForMatchingLevels");

  } if (parameter_name.islast()) {

    throw std::runtime_error("parameter_name needs to be a defined WorkspaceString since it is agenda input to abs_linesChangeBaseParameterForMatchingLevels");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceVector since it is agenda input to abs_linesChangeBaseParameterForMatchingLevels");

  } if (not relative.isnull() and relative.islast()) {

    throw std::runtime_error("relative needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_linesChangeBaseParameterForMatchingLevels");

  }


  static const auto relative_default = Var::IndexCreate(ws, 0,

    "abs_linesChangeBaseParameterForMatchingLevels_relative_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(152,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter_name.pos()), Group::Index(change.pos()), relative.isnull() ? Index(relative_default.pos()) : Group::Index(relative.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesChangeBaseParameterForMatchingLevel(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter_name,

               const Var::Numeric change,

               const Var::Index& relative={}) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesChangeBaseParameterForMatchingLevel");

  } if (parameter_name.islast()) {

    throw std::runtime_error("parameter_name needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesChangeBaseParameterForMatchingLevel");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesChangeBaseParameterForMatchingLevel");

  } if (not relative.isnull() and relative.islast()) {

    throw std::runtime_error("relative needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_lines_per_speciesChangeBaseParameterForMatchingLevel");

  }


  static const auto relative_default = Var::IndexCreate(ws, 0,

    "abs_lines_per_speciesChangeBaseParameterForMatchingLevel_relative_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(153,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter_name.pos()), Group::Index(change.pos()), relative.isnull() ? Index(relative_default.pos()) : Group::Index(relative.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesChangeBaseParameterForMatchingLevels(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier QI,

               const Var::String parameter_name,

               const Var::Vector change,

               const Var::Index& relative={}) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to abs_lines_per_speciesChangeBaseParameterForMatchingLevels");

  } if (parameter_name.islast()) {

    throw std::runtime_error("parameter_name needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesChangeBaseParameterForMatchingLevels");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceVector since it is agenda input to abs_lines_per_speciesChangeBaseParameterForMatchingLevels");

  } if (not relative.isnull() and relative.islast()) {

    throw std::runtime_error("relative needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_lines_per_speciesChangeBaseParameterForMatchingLevels");

  }


  static const auto relative_default = Var::IndexCreate(ws, 0,

    "abs_lines_per_speciesChangeBaseParameterForMatchingLevels_relative_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(154,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter_name.pos()), Group::Index(change.pos()), relative.isnull() ? Index(relative_default.pos()) : Group::Index(relative.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetBaseParameterForMatchingLevel(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter_name,

               const Var::Numeric change) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesSetBaseParameterForMatchingLevel");

  } if (parameter_name.islast()) {

    throw std::runtime_error("parameter_name needs to be a defined WorkspaceString since it is agenda input to abs_linesSetBaseParameterForMatchingLevel");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_linesSetBaseParameterForMatchingLevel");

  }


  return MRecord(155,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter_name.pos()), Group::Index(change.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetBaseParameterForMatchingLevels(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier QI,

               const Var::String parameter_name,

               const Var::Vector change) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to abs_linesSetBaseParameterForMatchingLevels");

  } if (parameter_name.islast()) {

    throw std::runtime_error("parameter_name needs to be a defined WorkspaceString since it is agenda input to abs_linesSetBaseParameterForMatchingLevels");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceVector since it is agenda input to abs_linesSetBaseParameterForMatchingLevels");

  }


  return MRecord(156,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter_name.pos()), Group::Index(change.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetBaseParameterForMatchingLevel(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter_name,

               const Var::Numeric change) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetBaseParameterForMatchingLevel");

  } if (parameter_name.islast()) {

    throw std::runtime_error("parameter_name needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetBaseParameterForMatchingLevel");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesSetBaseParameterForMatchingLevel");

  }


  return MRecord(157,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter_name.pos()), Group::Index(change.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetBaseParameterForMatchingLevels(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier QI,

               const Var::String parameter_name,

               const Var::Vector change) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetBaseParameterForMatchingLevels");

  } if (parameter_name.islast()) {

    throw std::runtime_error("parameter_name needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetBaseParameterForMatchingLevels");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceVector since it is agenda input to abs_lines_per_speciesSetBaseParameterForMatchingLevels");

  }


  return MRecord(158,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter_name.pos()), Group::Index(change.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesChangeBaseParameterForMatchingLines(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter_name,

               const Var::Numeric change,

               const Var::Index& relative={},

               const Var::Index& loose_matching={}) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesChangeBaseParameterForMatchingLines");

  } if (parameter_name.islast()) {

    throw std::runtime_error("parameter_name needs to be a defined WorkspaceString since it is agenda input to abs_linesChangeBaseParameterForMatchingLines");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_linesChangeBaseParameterForMatchingLines");

  } if (not relative.isnull() and relative.islast()) {

    throw std::runtime_error("relative needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_linesChangeBaseParameterForMatchingLines");

  } if (not loose_matching.isnull() and loose_matching.islast()) {

    throw std::runtime_error("loose_matching needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_linesChangeBaseParameterForMatchingLines");

  }


  static const auto relative_default = Var::IndexCreate(ws, 0,

    "abs_linesChangeBaseParameterForMatchingLines_relative_autodefault",

    "auto generated variable with default from method definition");

  static const auto loose_matching_default = Var::IndexCreate(ws, 0,

    "abs_linesChangeBaseParameterForMatchingLines_loose_matching_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(159,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter_name.pos()), Group::Index(change.pos()), relative.isnull() ? Index(relative_default.pos()) : Group::Index(relative.pos()), loose_matching.isnull() ? Index(loose_matching_default.pos()) : Group::Index(loose_matching.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesChangeBaseParameterForMatchingLines(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter_name,

               const Var::Numeric change,

               const Var::Index& relative={},

               const Var::Index& loose_matching={}) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesChangeBaseParameterForMatchingLines");

  } if (parameter_name.islast()) {

    throw std::runtime_error("parameter_name needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesChangeBaseParameterForMatchingLines");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesChangeBaseParameterForMatchingLines");

  } if (not relative.isnull() and relative.islast()) {

    throw std::runtime_error("relative needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_lines_per_speciesChangeBaseParameterForMatchingLines");

  } if (not loose_matching.isnull() and loose_matching.islast()) {

    throw std::runtime_error("loose_matching needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_lines_per_speciesChangeBaseParameterForMatchingLines");

  }


  static const auto relative_default = Var::IndexCreate(ws, 0,

    "abs_lines_per_speciesChangeBaseParameterForMatchingLines_relative_autodefault",

    "auto generated variable with default from method definition");

  static const auto loose_matching_default = Var::IndexCreate(ws, 0,

    "abs_lines_per_speciesChangeBaseParameterForMatchingLines_loose_matching_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(160,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter_name.pos()), Group::Index(change.pos()), relative.isnull() ? Index(relative_default.pos()) : Group::Index(relative.pos()), loose_matching.isnull() ? Index(loose_matching_default.pos()) : Group::Index(loose_matching.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesChangeBaseParameterForSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter_name,

               const Var::Numeric change,

               const Var::String species_tag,

               const Var::Index& relative={},

               const Var::Index& loose_matching={}) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesChangeBaseParameterForSpecies");

  } if (parameter_name.islast()) {

    throw std::runtime_error("parameter_name needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesChangeBaseParameterForSpecies");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesChangeBaseParameterForSpecies");

  } if (not relative.isnull() and relative.islast()) {

    throw std::runtime_error("relative needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_lines_per_speciesChangeBaseParameterForSpecies");

  } if (not loose_matching.isnull() and loose_matching.islast()) {

    throw std::runtime_error("loose_matching needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_lines_per_speciesChangeBaseParameterForSpecies");

  } if (species_tag.islast()) {

    throw std::runtime_error("species_tag needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesChangeBaseParameterForSpecies");

  }


  static const auto relative_default = Var::IndexCreate(ws, 0,

    "abs_lines_per_speciesChangeBaseParameterForSpecies_relative_autodefault",

    "auto generated variable with default from method definition");

  static const auto loose_matching_default = Var::IndexCreate(ws, 0,

    "abs_lines_per_speciesChangeBaseParameterForSpecies_loose_matching_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(161,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({21, Group::Index(QI.pos()), Group::Index(parameter_name.pos()), Group::Index(change.pos()), relative.isnull() ? Index(relative_default.pos()) : Group::Index(relative.pos()), loose_matching.isnull() ? Index(loose_matching_default.pos()) : Group::Index(loose_matching.pos()), Group::Index(species_tag.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetBaseParameterForMatchingLines(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter_name,

               const Var::Numeric change,

               const Var::Index& loose_matching={}) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesSetBaseParameterForMatchingLines");

  } if (parameter_name.islast()) {

    throw std::runtime_error("parameter_name needs to be a defined WorkspaceString since it is agenda input to abs_linesSetBaseParameterForMatchingLines");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_linesSetBaseParameterForMatchingLines");

  } if (not loose_matching.isnull() and loose_matching.islast()) {

    throw std::runtime_error("loose_matching needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_linesSetBaseParameterForMatchingLines");

  }


  static const auto loose_matching_default = Var::IndexCreate(ws, 0,

    "abs_linesSetBaseParameterForMatchingLines_loose_matching_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(162,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter_name.pos()), Group::Index(change.pos()), loose_matching.isnull() ? Index(loose_matching_default.pos()) : Group::Index(loose_matching.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetBaseParameterForMatchingLines(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter_name,

               const Var::Numeric change,

               const Var::Index& loose_matching={}) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetBaseParameterForMatchingLines");

  } if (parameter_name.islast()) {

    throw std::runtime_error("parameter_name needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetBaseParameterForMatchingLines");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesSetBaseParameterForMatchingLines");

  } if (not loose_matching.isnull() and loose_matching.islast()) {

    throw std::runtime_error("loose_matching needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_lines_per_speciesSetBaseParameterForMatchingLines");

  }


  static const auto loose_matching_default = Var::IndexCreate(ws, 0,

    "abs_lines_per_speciesSetBaseParameterForMatchingLines_loose_matching_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(163,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter_name.pos()), Group::Index(change.pos()), loose_matching.isnull() ? Index(loose_matching_default.pos()) : Group::Index(loose_matching.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetBaseParameterForSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter_name,

               const Var::Numeric change,

               const Var::String species_tag,

               const Var::Index& loose_matching={}) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetBaseParameterForSpecies");

  } if (parameter_name.islast()) {

    throw std::runtime_error("parameter_name needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetBaseParameterForSpecies");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesSetBaseParameterForSpecies");

  } if (not loose_matching.isnull() and loose_matching.islast()) {

    throw std::runtime_error("loose_matching needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_lines_per_speciesSetBaseParameterForSpecies");

  } if (species_tag.islast()) {

    throw std::runtime_error("species_tag needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetBaseParameterForSpecies");

  }


  static const auto loose_matching_default = Var::IndexCreate(ws, 0,

    "abs_lines_per_speciesSetBaseParameterForSpecies_loose_matching_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(164,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({21, Group::Index(QI.pos()), Group::Index(parameter_name.pos()), Group::Index(change.pos()), loose_matching.isnull() ? Index(loose_matching_default.pos()) : Group::Index(loose_matching.pos()), Group::Index(species_tag.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetLineShapeModelParameterForMatchingLines(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter,

               const Var::String coefficient,

               const Var::String species,

               const Var::Numeric change) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesSetLineShapeModelParameterForMatchingLines");

  } if (parameter.islast()) {

    throw std::runtime_error("parameter needs to be a defined WorkspaceString since it is agenda input to abs_linesSetLineShapeModelParameterForMatchingLines");

  } if (coefficient.islast()) {

    throw std::runtime_error("coefficient needs to be a defined WorkspaceString since it is agenda input to abs_linesSetLineShapeModelParameterForMatchingLines");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to abs_linesSetLineShapeModelParameterForMatchingLines");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_linesSetLineShapeModelParameterForMatchingLines");

  }


  return MRecord(165,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter.pos()), Group::Index(coefficient.pos()), Group::Index(species.pos()), Group::Index(change.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetLineShapeModelParameterForMatchingLines(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter,

               const Var::String coefficient,

               const Var::String species,

               const Var::Numeric change) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetLineShapeModelParameterForMatchingLines");

  } if (parameter.islast()) {

    throw std::runtime_error("parameter needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetLineShapeModelParameterForMatchingLines");

  } if (coefficient.islast()) {

    throw std::runtime_error("coefficient needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetLineShapeModelParameterForMatchingLines");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetLineShapeModelParameterForMatchingLines");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesSetLineShapeModelParameterForMatchingLines");

  }


  return MRecord(166,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter.pos()), Group::Index(coefficient.pos()), Group::Index(species.pos()), Group::Index(change.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetLineShapeModelParameterForSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter,

               const Var::String coefficient,

               const Var::String species,

               const Var::Numeric change,

               const Var::String species_tag) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetLineShapeModelParameterForSpecies");

  } if (parameter.islast()) {

    throw std::runtime_error("parameter needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetLineShapeModelParameterForSpecies");

  } if (coefficient.islast()) {

    throw std::runtime_error("coefficient needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetLineShapeModelParameterForSpecies");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetLineShapeModelParameterForSpecies");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesSetLineShapeModelParameterForSpecies");

  } if (species_tag.islast()) {

    throw std::runtime_error("species_tag needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesSetLineShapeModelParameterForSpecies");

  }


  return MRecord(167,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({21, Group::Index(QI.pos()), Group::Index(parameter.pos()), Group::Index(coefficient.pos()), Group::Index(species.pos()), Group::Index(change.pos()), Group::Index(species_tag.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesSetZeemanCoefficients(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier qid,

               const Var::Vector gs) {

  if (qid.islast()) {

    throw std::runtime_error("qid needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to abs_linesSetZeemanCoefficients");

  } if (gs.islast()) {

    throw std::runtime_error("gs needs to be a defined WorkspaceVector since it is agenda input to abs_linesSetZeemanCoefficients");

  }


  return MRecord(168,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(qid.pos()), Group::Index(gs.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesSetZeemanCoefficients(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier qid,

               const Var::Vector gs) {

  if (qid.islast()) {

    throw std::runtime_error("qid needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to abs_lines_per_speciesSetZeemanCoefficients");

  } if (gs.islast()) {

    throw std::runtime_error("gs needs to be a defined WorkspaceVector since it is agenda input to abs_lines_per_speciesSetZeemanCoefficients");

  }


  return MRecord(169,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(qid.pos()), Group::Index(gs.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesChangeLineShapeModelParameterForMatchingLines(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter,

               const Var::String coefficient,

               const Var::String species,

               const Var::Numeric change,

               const Var::Index& relative={}) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_linesChangeLineShapeModelParameterForMatchingLines");

  } if (parameter.islast()) {

    throw std::runtime_error("parameter needs to be a defined WorkspaceString since it is agenda input to abs_linesChangeLineShapeModelParameterForMatchingLines");

  } if (coefficient.islast()) {

    throw std::runtime_error("coefficient needs to be a defined WorkspaceString since it is agenda input to abs_linesChangeLineShapeModelParameterForMatchingLines");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to abs_linesChangeLineShapeModelParameterForMatchingLines");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_linesChangeLineShapeModelParameterForMatchingLines");

  } if (not relative.isnull() and relative.islast()) {

    throw std::runtime_error("relative needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_linesChangeLineShapeModelParameterForMatchingLines");

  }


  static const auto relative_default = Var::IndexCreate(ws, 0,

    "abs_linesChangeLineShapeModelParameterForMatchingLines_relative_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(170,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter.pos()), Group::Index(coefficient.pos()), Group::Index(species.pos()), Group::Index(change.pos()), relative.isnull() ? Index(relative_default.pos()) : Group::Index(relative.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesChangeLineShapeModelParameterForMatchingLines(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter,

               const Var::String coefficient,

               const Var::String species,

               const Var::Numeric change,

               const Var::Index& relative={}) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesChangeLineShapeModelParameterForMatchingLines");

  } if (parameter.islast()) {

    throw std::runtime_error("parameter needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesChangeLineShapeModelParameterForMatchingLines");

  } if (coefficient.islast()) {

    throw std::runtime_error("coefficient needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesChangeLineShapeModelParameterForMatchingLines");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesChangeLineShapeModelParameterForMatchingLines");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesChangeLineShapeModelParameterForMatchingLines");

  } if (not relative.isnull() and relative.islast()) {

    throw std::runtime_error("relative needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_lines_per_speciesChangeLineShapeModelParameterForMatchingLines");

  }


  static const auto relative_default = Var::IndexCreate(ws, 0,

    "abs_lines_per_speciesChangeLineShapeModelParameterForMatchingLines_relative_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(171,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({Group::Index(QI.pos()), Group::Index(parameter.pos()), Group::Index(coefficient.pos()), Group::Index(species.pos()), Group::Index(change.pos()), relative.isnull() ? Index(relative_default.pos()) : Group::Index(relative.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesChangeLineShapeModelParameterForSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier QI,

               const Var::String parameter,

               const Var::String coefficient,

               const Var::String species,

               const Var::Numeric change,

               const Var::String species_tag,

               const Var::Index& relative={}) {

  if (QI.islast()) {

    throw std::runtime_error("QI needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to abs_lines_per_speciesChangeLineShapeModelParameterForSpecies");

  } if (parameter.islast()) {

    throw std::runtime_error("parameter needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesChangeLineShapeModelParameterForSpecies");

  } if (coefficient.islast()) {

    throw std::runtime_error("coefficient needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesChangeLineShapeModelParameterForSpecies");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesChangeLineShapeModelParameterForSpecies");

  } if (change.islast()) {

    throw std::runtime_error("change needs to be a defined WorkspaceNumeric since it is agenda input to abs_lines_per_speciesChangeLineShapeModelParameterForSpecies");

  } if (not relative.isnull() and relative.islast()) {

    throw std::runtime_error("relative needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_lines_per_speciesChangeLineShapeModelParameterForSpecies");

  } if (species_tag.islast()) {

    throw std::runtime_error("species_tag needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesChangeLineShapeModelParameterForSpecies");

  }


  static const auto relative_default = Var::IndexCreate(ws, 0,

    "abs_lines_per_speciesChangeLineShapeModelParameterForSpecies_relative_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(172,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({21, Group::Index(QI.pos()), Group::Index(parameter.pos()), Group::Index(coefficient.pos()), Group::Index(species.pos()), Group::Index(change.pos()), relative.isnull() ? Index(relative_default.pos()) : Group::Index(relative.pos()), Group::Index(species_tag.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesCompact(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(173,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({104, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesCompact(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(174,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({104, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesCreateFromLines(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(175,

    Group::ArrayOfIndex({11, }),

    Group::ArrayOfIndex({10, 21, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lookupAdapt(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(176,

    Group::ArrayOfIndex({12, 19, }),

    Group::ArrayOfIndex({21, 104, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lookupCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(177,

    Group::ArrayOfIndex({12, 19, }),

    Group::ArrayOfIndex({21, 13, 104, 20, 27, 23, 17, 14, 29, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lookupInit(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(178,

    Group::ArrayOfIndex({12, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lookupSetup(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& p_step={},

               const Var::Numeric& t_step={},

               const Var::Numeric& h2o_step={}) {

  if (not p_step.isnull() and p_step.islast()) {

    throw std::runtime_error("p_step needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_lookupSetup");

  } if (not t_step.isnull() and t_step.islast()) {

    throw std::runtime_error("t_step needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_lookupSetup");

  } if (not h2o_step.isnull() and h2o_step.islast()) {

    throw std::runtime_error("h2o_step needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_lookupSetup");

  }


  static const auto p_step_default = Var::NumericCreate(ws, 0.05,

    "abs_lookupSetup_p_step_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_step_default = Var::NumericCreate(ws, 100,

    "abs_lookupSetup_t_step_autodefault",

    "auto generated variable with default from method definition");

  static const auto h2o_step_default = Var::NumericCreate(ws, 100,

    "abs_lookupSetup_h2o_step_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(179,

    Group::ArrayOfIndex({20, 23, 17, 27, 13, 14, }),

    Group::ArrayOfIndex({35, 242, 338, 344, 36, 21, 16, 18, 15, p_step.isnull() ? Index(p_step_default.pos()) : Group::Index(p_step.pos()), t_step.isnull() ? Index(t_step_default.pos()) : Group::Index(t_step.pos()), h2o_step.isnull() ? Index(h2o_step_default.pos()) : Group::Index(h2o_step.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lookupSetupBatch(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& p_step={},

               const Var::Numeric& t_step={},

               const Var::Numeric& h2o_step={},

               const Var::Vector& extremes={},

               const Var::Index& robust={},

               const Var::Index& check_gridnames={}) {

  if (not p_step.isnull() and p_step.islast()) {

    throw std::runtime_error("p_step needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_lookupSetupBatch");

  } if (not t_step.isnull() and t_step.islast()) {

    throw std::runtime_error("t_step needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_lookupSetupBatch");

  } if (not h2o_step.isnull() and h2o_step.islast()) {

    throw std::runtime_error("h2o_step needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_lookupSetupBatch");

  } if (not extremes.isnull() and extremes.islast()) {

    throw std::runtime_error("extremes needs to be a defined WorkspaceVector (or left default) since it is agenda input to abs_lookupSetupBatch");

  } if (not robust.isnull() and robust.islast()) {

    throw std::runtime_error("robust needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_lookupSetupBatch");

  } if (not check_gridnames.isnull() and check_gridnames.islast()) {

    throw std::runtime_error("check_gridnames needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_lookupSetupBatch");

  }


  static const auto p_step_default = Var::NumericCreate(ws, 0.05,

    "abs_lookupSetupBatch_p_step_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_step_default = Var::NumericCreate(ws, 20,

    "abs_lookupSetupBatch_t_step_autodefault",

    "auto generated variable with default from method definition");

  static const auto h2o_step_default = Var::NumericCreate(ws, 100,

    "abs_lookupSetupBatch_h2o_step_autodefault",

    "auto generated variable with default from method definition");

  static const auto extremes_default = Var::VectorCreate(ws, {},

    "abs_lookupSetupBatch_extremes_autodefault",

    "auto generated variable with default from method definition");

  static const auto robust_default = Var::IndexCreate(ws, 0,

    "abs_lookupSetupBatch_robust_autodefault",

    "auto generated variable with default from method definition");

  static const auto check_gridnames_default = Var::IndexCreate(ws, 0,

    "abs_lookupSetupBatch_check_gridnames_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(180,

    Group::ArrayOfIndex({20, 23, 17, 27, 13, 14, }),

    Group::ArrayOfIndex({21, 42, 16, 18, 15, 35, p_step.isnull() ? Index(p_step_default.pos()) : Group::Index(p_step.pos()), t_step.isnull() ? Index(t_step_default.pos()) : Group::Index(t_step.pos()), h2o_step.isnull() ? Index(h2o_step_default.pos()) : Group::Index(h2o_step.pos()), extremes.isnull() ? Index(extremes_default.pos()) : Group::Index(extremes.pos()), robust.isnull() ? Index(robust_default.pos()) : Group::Index(robust.pos()), check_gridnames.isnull() ? Index(check_gridnames_default.pos()) : Group::Index(check_gridnames.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lookupSetupWide(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& p_min={},

               const Var::Numeric& p_max={},

               const Var::Numeric& p_step={},

               const Var::Numeric& t_min={},

               const Var::Numeric& t_max={},

               const Var::Numeric& h2o_min={},

               const Var::Numeric& h2o_max={}) {

  if (not p_min.isnull() and p_min.islast()) {

    throw std::runtime_error("p_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_lookupSetupWide");

  } if (not p_max.isnull() and p_max.islast()) {

    throw std::runtime_error("p_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_lookupSetupWide");

  } if (not p_step.isnull() and p_step.islast()) {

    throw std::runtime_error("p_step needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_lookupSetupWide");

  } if (not t_min.isnull() and t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_lookupSetupWide");

  } if (not t_max.isnull() and t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_lookupSetupWide");

  } if (not h2o_min.isnull() and h2o_min.islast()) {

    throw std::runtime_error("h2o_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_lookupSetupWide");

  } if (not h2o_max.isnull() and h2o_max.islast()) {

    throw std::runtime_error("h2o_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_lookupSetupWide");

  }


  static const auto p_min_default = Var::NumericCreate(ws, 0.5,

    "abs_lookupSetupWide_p_min_autodefault",

    "auto generated variable with default from method definition");

  static const auto p_max_default = Var::NumericCreate(ws, 110000,

    "abs_lookupSetupWide_p_max_autodefault",

    "auto generated variable with default from method definition");

  static const auto p_step_default = Var::NumericCreate(ws, 0.05,

    "abs_lookupSetupWide_p_step_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_min_default = Var::NumericCreate(ws, 100,

    "abs_lookupSetupWide_t_min_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_max_default = Var::NumericCreate(ws, 400,

    "abs_lookupSetupWide_t_max_autodefault",

    "auto generated variable with default from method definition");

  static const auto h2o_min_default = Var::NumericCreate(ws, 0,

    "abs_lookupSetupWide_h2o_min_autodefault",

    "auto generated variable with default from method definition");

  static const auto h2o_max_default = Var::NumericCreate(ws, 0.05,

    "abs_lookupSetupWide_h2o_max_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(181,

    Group::ArrayOfIndex({20, 23, 17, 27, 13, 14, }),

    Group::ArrayOfIndex({21, 16, 18, 15, p_min.isnull() ? Index(p_min_default.pos()) : Group::Index(p_min.pos()), p_max.isnull() ? Index(p_max_default.pos()) : Group::Index(p_max.pos()), p_step.isnull() ? Index(p_step_default.pos()) : Group::Index(p_step.pos()), t_min.isnull() ? Index(t_min_default.pos()) : Group::Index(t_min.pos()), t_max.isnull() ? Index(t_max_default.pos()) : Group::Index(t_max.pos()), h2o_min.isnull() ? Index(h2o_min_default.pos()) : Group::Index(h2o_min.pos()), h2o_max.isnull() ? Index(h2o_max_default.pos()) : Group::Index(h2o_max.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lookupTestAccuracy(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(182,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({12, 19, 16, 18, 15, 29, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lookupTestAccMC(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(183,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({12, 19, 16, 18, 15, 168, 29, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_nlteFromRaw(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix data) {

  if (data.islast()) {

    throw std::runtime_error("data needs to be a defined WorkspaceMatrix since it is agenda input to abs_nlteFromRaw");

  }


  return MRecord(184,

    Group::ArrayOfIndex({24, }),

    Group::ArrayOfIndex({179, 180, Group::Index(data.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_speciesAdd(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfString species) {

  if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceArrayOfString since it is agenda input to abs_speciesAdd");

  }


  return MRecord(185,

    Group::ArrayOfIndex({21, 237, 28, }),

    Group::ArrayOfIndex({Group::Index(species.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_speciesAdd2(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector gin1,

               const Var::Vector gin2,

               const Var::Vector gin3,

               const Var::String species,

               const Var::String& unit={}) {

  if (gin1.islast()) {

    throw std::runtime_error("gin1 needs to be a defined WorkspaceVector since it is agenda input to abs_speciesAdd2");

  } if (gin2.islast()) {

    throw std::runtime_error("gin2 needs to be a defined WorkspaceVector since it is agenda input to abs_speciesAdd2");

  } if (gin3.islast()) {

    throw std::runtime_error("gin3 needs to be a defined WorkspaceVector since it is agenda input to abs_speciesAdd2");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to abs_speciesAdd2");

  } if (not unit.isnull() and unit.islast()) {

    throw std::runtime_error("unit needs to be a defined WorkspaceString (or left default) since it is agenda input to abs_speciesAdd2");

  }


  static const auto unit_default = Var::StringCreate(ws, "vmr",

    "abs_speciesAdd2_unit_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(186,

    Group::ArrayOfIndex({21, 137, 135, 237, 28, }),

    Group::ArrayOfIndex({35, 242, 139, 147, Group::Index(gin1.pos()), Group::Index(gin2.pos()), Group::Index(gin3.pos()), Group::Index(species.pos()), unit.isnull() ? Index(unit_default.pos()) : Group::Index(unit.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_speciesDefineAllInScenario(

    [[maybe_unused]] Workspace& ws,

               const Var::String basename) {

  if (basename.islast()) {

    throw std::runtime_error("basename needs to be a defined WorkspaceString since it is agenda input to abs_speciesDefineAllInScenario");

  }


  return MRecord(187,

    Group::ArrayOfIndex({21, 237, 28, }),

    Group::ArrayOfIndex({Group::Index(basename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_speciesDefineAll(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(188,

    Group::ArrayOfIndex({21, 237, 28, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_speciesInit(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(189,

    Group::ArrayOfIndex({21, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_speciesSet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfString species) {

  if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceArrayOfString since it is agenda input to abs_speciesSet");

  }


  return MRecord(190,

    Group::ArrayOfIndex({21, 28, 237, }),

    Group::ArrayOfIndex({Group::Index(species.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_vecAddGas(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(191,

    Group::ArrayOfIndex({25, }),

    Group::ArrayOfIndex({236, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_xsec_agenda_checkedCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(192,

    Group::ArrayOfIndex({28, }),

    Group::ArrayOfIndex({21, 29, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_xsec_per_speciesAddCIA(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& T_extrapolfac={},

               const Var::Index& robust={}) {

  if (not T_extrapolfac.isnull() and T_extrapolfac.islast()) {

    throw std::runtime_error("T_extrapolfac needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_xsec_per_speciesAddCIA");

  } if (not robust.isnull() and robust.islast()) {

    throw std::runtime_error("robust needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_xsec_per_speciesAddCIA");

  }


  static const auto T_extrapolfac_default = Var::NumericCreate(ws, 0.5,

    "abs_xsec_per_speciesAddCIA_T_extrapolfac_autodefault",

    "auto generated variable with default from method definition");

  static const auto robust_default = Var::IndexCreate(ws, 0,

    "abs_xsec_per_speciesAddCIA_robust_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(193,

    Group::ArrayOfIndex({30, 64, }),

    Group::ArrayOfIndex({21, 137, 22, 104, 20, 23, 27, 2, T_extrapolfac.isnull() ? Index(T_extrapolfac_default.pos()) : Group::Index(T_extrapolfac.pos()), robust.isnull() ? Index(robust_default.pos()) : Group::Index(robust.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_xsec_per_speciesAddHitranXsec(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& apply_tfit={},

               const Var::Numeric& force_p={},

               const Var::Numeric& force_t={}) {

  if (not apply_tfit.isnull() and apply_tfit.islast()) {

    throw std::runtime_error("apply_tfit needs to be a defined WorkspaceIndex (or left default) since it is agenda input to abs_xsec_per_speciesAddHitranXsec");

  } if (not force_p.isnull() and force_p.islast()) {

    throw std::runtime_error("force_p needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_xsec_per_speciesAddHitranXsec");

  } if (not force_t.isnull() and force_t.islast()) {

    throw std::runtime_error("force_t needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to abs_xsec_per_speciesAddHitranXsec");

  }


  static const auto apply_tfit_default = Var::IndexCreate(ws, 1,

    "abs_xsec_per_speciesAddHitranXsec_apply_tfit_autodefault",

    "auto generated variable with default from method definition");

  static const auto force_p_default = Var::NumericCreate(ws, -1,

    "abs_xsec_per_speciesAddHitranXsec_force_p_autodefault",

    "auto generated variable with default from method definition");

  static const auto force_t_default = Var::NumericCreate(ws, -1,

    "abs_xsec_per_speciesAddHitranXsec_force_t_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(194,

    Group::ArrayOfIndex({30, 64, }),

    Group::ArrayOfIndex({21, 137, 22, 104, 20, 23, 111, apply_tfit.isnull() ? Index(apply_tfit_default.pos()) : Group::Index(apply_tfit.pos()), force_p.isnull() ? Index(force_p_default.pos()) : Group::Index(force_p.pos()), force_t.isnull() ? Index(force_t_default.pos()) : Group::Index(force_t.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_xsec_per_speciesAddConts(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(195,

    Group::ArrayOfIndex({30, 64, }),

    Group::ArrayOfIndex({21, 137, 22, 104, 20, 23, 27, 6, 7, 5, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_xsec_per_speciesAddLines(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(196,

    Group::ArrayOfIndex({30, 307, 64, 71, }),

    Group::ArrayOfIndex({21, 137, 22, 104, 20, 23, 24, 27, 11, 117, 200, 141, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_xsec_per_speciesAddPredefinedO2MPM2020(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(197,

    Group::ArrayOfIndex({30, 64, }),

    Group::ArrayOfIndex({21, 137, 104, 20, 23, 27, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_xsec_per_speciesInit(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(198,

    Group::ArrayOfIndex({30, 307, 64, 71, }),

    Group::ArrayOfIndex({21, 137, 22, 104, 20, 28, 191, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AddZaAa(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix new_los,

               const Var::Vector ref_los,

               const Var::Matrix dlos) {

  if (new_los.islast()) {

    throw std::runtime_error("new_los needs to be a defined WorkspaceMatrix since it is output of AddZaAa");

  } if (ref_los.islast()) {

    throw std::runtime_error("ref_los needs to be a defined WorkspaceVector since it is agenda input to AddZaAa");

  } if (dlos.islast()) {

    throw std::runtime_error("dlos needs to be a defined WorkspaceMatrix since it is agenda input to AddZaAa");

  }


  return MRecord(199,

    Group::ArrayOfIndex({Group::Index(new_los.pos()), }),

    Group::ArrayOfIndex({Group::Index(ref_los.pos()), Group::Index(dlos.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AgendaExecute(

    [[maybe_unused]] Workspace& ws,

               const Var::Agenda a) {

  if (a.islast()) {

    throw std::runtime_error("a needs to be a defined WorkspaceAgenda since it is agenda input to AgendaExecute");

  }


  return MRecord(201,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(a.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AgendaExecuteExclusive(

    [[maybe_unused]] Workspace& ws,

               const Var::Agenda a) {

  if (a.islast()) {

    throw std::runtime_error("a needs to be a defined WorkspaceAgenda since it is agenda input to AgendaExecuteExclusive");

  }


  return MRecord(202,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(a.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AngularGridsSetFluxCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& N_za_grid={},

               const Var::Index& N_aa_grid={},

               const Var::String& za_grid_type={}) {

  if (not N_za_grid.isnull() and N_za_grid.islast()) {

    throw std::runtime_error("N_za_grid needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AngularGridsSetFluxCalc");

  } if (not N_aa_grid.isnull() and N_aa_grid.islast()) {

    throw std::runtime_error("N_aa_grid needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AngularGridsSetFluxCalc");

  } if (not za_grid_type.isnull() and za_grid_type.islast()) {

    throw std::runtime_error("za_grid_type needs to be a defined WorkspaceString (or left default) since it is agenda input to AngularGridsSetFluxCalc");

  }


  static const auto N_za_grid_default = Var::IndexCreate(ws, 2,

    "AngularGridsSetFluxCalc_N_za_grid_autodefault",

    "auto generated variable with default from method definition");

  static const auto N_aa_grid_default = Var::IndexCreate(ws, 1,

    "AngularGridsSetFluxCalc_N_aa_grid_autodefault",

    "auto generated variable with default from method definition");

  static const auto za_grid_type_default = Var::StringCreate(ws, "linear_mu",

    "AngularGridsSetFluxCalc_za_grid_type_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(204,

    Group::ArrayOfIndex({378, 0, 379, }),

    Group::ArrayOfIndex({N_za_grid.isnull() ? Index(N_za_grid_default.pos()) : Group::Index(N_za_grid.pos()), N_aa_grid.isnull() ? Index(N_aa_grid_default.pos()) : Group::Index(N_aa_grid.pos()), za_grid_type.isnull() ? Index(za_grid_type_default.pos()) : Group::Index(za_grid_type.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ArrayOfAgendaExecute(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAgenda agendas) {

  if (agendas.islast()) {

    throw std::runtime_error("agendas needs to be a defined WorkspaceArrayOfAgenda since it is agenda input to ArrayOfAgendaExecute");

  }


  return MRecord(206,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({31, Group::Index(agendas.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AntennaConstantGaussian1D(

    [[maybe_unused]] Workspace& ws,

               const Var::Index n_za_grid,

               const Var::Numeric fwhm,

               const Var::Numeric& xwidth_si={},

               const Var::Numeric& dx_si={}) {

  if (n_za_grid.islast()) {

    throw std::runtime_error("n_za_grid needs to be a defined WorkspaceIndex since it is agenda input to AntennaConstantGaussian1D");

  } if (fwhm.islast()) {

    throw std::runtime_error("fwhm needs to be a defined WorkspaceNumeric since it is agenda input to AntennaConstantGaussian1D");

  } if (not xwidth_si.isnull() and xwidth_si.islast()) {

    throw std::runtime_error("xwidth_si needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to AntennaConstantGaussian1D");

  } if (not dx_si.isnull() and dx_si.islast()) {

    throw std::runtime_error("dx_si needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to AntennaConstantGaussian1D");

  }


  static const auto xwidth_si_default = Var::NumericCreate(ws, 3,

    "AntennaConstantGaussian1D_xwidth_si_autodefault",

    "auto generated variable with default from method definition");

  static const auto dx_si_default = Var::NumericCreate(ws, 0.1,

    "AntennaConstantGaussian1D_dx_si_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(207,

    Group::ArrayOfIndex({32, 156, 34, 33, }),

    Group::ArrayOfIndex({Group::Index(n_za_grid.pos()), Group::Index(fwhm.pos()), xwidth_si.isnull() ? Index(xwidth_si_default.pos()) : Group::Index(xwidth_si.pos()), dx_si.isnull() ? Index(dx_si_default.pos()) : Group::Index(dx_si.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AntennaMultiBeamsToPencilBeams(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(208,

    Group::ArrayOfIndex({286, 283, 33, 32, 156, }),

    Group::ArrayOfIndex({35, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AntennaOff(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(209,

    Group::ArrayOfIndex({32, 156, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord antenna_responseGaussian(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric fwhm,

               const Var::Numeric& xwidth_si={},

               const Var::Numeric& dx_si={},

               const Var::Index& do_2d={}) {

  if (fwhm.islast()) {

    throw std::runtime_error("fwhm needs to be a defined WorkspaceNumeric since it is agenda input to antenna_responseGaussian");

  } if (not xwidth_si.isnull() and xwidth_si.islast()) {

    throw std::runtime_error("xwidth_si needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to antenna_responseGaussian");

  } if (not dx_si.isnull() and dx_si.islast()) {

    throw std::runtime_error("dx_si needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to antenna_responseGaussian");

  } if (not do_2d.isnull() and do_2d.islast()) {

    throw std::runtime_error("do_2d needs to be a defined WorkspaceIndex (or left default) since it is agenda input to antenna_responseGaussian");

  }


  static const auto xwidth_si_default = Var::NumericCreate(ws, 3,

    "antenna_responseGaussian_xwidth_si_autodefault",

    "auto generated variable with default from method definition");

  static const auto dx_si_default = Var::NumericCreate(ws, 0.1,

    "antenna_responseGaussian_dx_si_autodefault",

    "auto generated variable with default from method definition");

  static const auto do_2d_default = Var::IndexCreate(ws, 0,

    "antenna_responseGaussian_do_2d_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(210,

    Group::ArrayOfIndex({34, }),

    Group::ArrayOfIndex({Group::Index(fwhm.pos()), xwidth_si.isnull() ? Index(xwidth_si_default.pos()) : Group::Index(xwidth_si.pos()), dx_si.isnull() ? Index(dx_si_default.pos()) : Group::Index(dx_si.pos()), do_2d.isnull() ? Index(do_2d_default.pos()) : Group::Index(do_2d.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord antenna_responseVaryingGaussian(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric leff,

               const Var::Index nf,

               const Var::Numeric fstart,

               const Var::Numeric fstop,

               const Var::Numeric& xwidth_si={},

               const Var::Numeric& dx_si={},

               const Var::Index& do_2d={}) {

  if (leff.islast()) {

    throw std::runtime_error("leff needs to be a defined WorkspaceNumeric since it is agenda input to antenna_responseVaryingGaussian");

  } if (not xwidth_si.isnull() and xwidth_si.islast()) {

    throw std::runtime_error("xwidth_si needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to antenna_responseVaryingGaussian");

  } if (not dx_si.isnull() and dx_si.islast()) {

    throw std::runtime_error("dx_si needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to antenna_responseVaryingGaussian");

  } if (nf.islast()) {

    throw std::runtime_error("nf needs to be a defined WorkspaceIndex since it is agenda input to antenna_responseVaryingGaussian");

  } if (fstart.islast()) {

    throw std::runtime_error("fstart needs to be a defined WorkspaceNumeric since it is agenda input to antenna_responseVaryingGaussian");

  } if (fstop.islast()) {

    throw std::runtime_error("fstop needs to be a defined WorkspaceNumeric since it is agenda input to antenna_responseVaryingGaussian");

  } if (not do_2d.isnull() and do_2d.islast()) {

    throw std::runtime_error("do_2d needs to be a defined WorkspaceIndex (or left default) since it is agenda input to antenna_responseVaryingGaussian");

  }


  static const auto xwidth_si_default = Var::NumericCreate(ws, 3,

    "antenna_responseVaryingGaussian_xwidth_si_autodefault",

    "auto generated variable with default from method definition");

  static const auto dx_si_default = Var::NumericCreate(ws, 0.1,

    "antenna_responseVaryingGaussian_dx_si_autodefault",

    "auto generated variable with default from method definition");

  static const auto do_2d_default = Var::IndexCreate(ws, 0,

    "antenna_responseVaryingGaussian_do_2d_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(211,

    Group::ArrayOfIndex({34, }),

    Group::ArrayOfIndex({Group::Index(leff.pos()), xwidth_si.isnull() ? Index(xwidth_si_default.pos()) : Group::Index(xwidth_si.pos()), dx_si.isnull() ? Index(dx_si_default.pos()) : Group::Index(dx_si.pos()), Group::Index(nf.pos()), Group::Index(fstart.pos()), Group::Index(fstop.pos()), do_2d.isnull() ? Index(do_2d_default.pos()) : Group::Index(do_2d.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Numeric in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceNumeric since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(212,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Vector in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(213,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Matrix in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(214,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Vector in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(215,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 out,

               const Var::Matrix in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(216,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 out,

               const Var::Tensor3 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(217,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 out,

               const Var::Tensor3 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(218,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 out,

               const Var::Tensor4 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(219,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::String out,

               const Var::String in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceString since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceString since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(220,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfAbsorptionLines out,

               const Var::ArrayOfAbsorptionLines in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAbsorptionLines since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAbsorptionLines since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(221,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfAbsorptionLines out,

               const Var::ArrayOfArrayOfAbsorptionLines in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(222,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfAgenda out,

               const Var::ArrayOfAgenda in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAgenda since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAgenda since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(223,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField1 out,

               const Var::ArrayOfArrayOfGriddedField1 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(224,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField2 out,

               const Var::ArrayOfArrayOfGriddedField2 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(225,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField3 out,

               const Var::ArrayOfArrayOfGriddedField3 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(226,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfIndex out,

               const Var::ArrayOfArrayOfIndex in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfIndex since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfIndex since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(227,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfMatrix out,

               const Var::ArrayOfArrayOfMatrix in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(228,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfPpath out,

               const Var::ArrayOfPpath in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPpath since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPpath since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(229,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfPropagationMatrix out,

               const Var::ArrayOfArrayOfPropagationMatrix in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(230,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfRadiationVector out,

               const Var::ArrayOfArrayOfRadiationVector in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(231,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfScatteringMetaData out,

               const Var::ArrayOfArrayOfScatteringMetaData in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(232,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfSingleScatteringData out,

               const Var::ArrayOfArrayOfSingleScatteringData in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(233,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfSpeciesTag out,

               const Var::ArrayOfArrayOfSpeciesTag in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(234,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfStokesVector out,

               const Var::ArrayOfArrayOfStokesVector in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(235,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfString out,

               const Var::ArrayOfArrayOfString in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfString since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfString since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(236,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTensor3 out,

               const Var::ArrayOfArrayOfTensor3 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(237,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTensor6 out,

               const Var::ArrayOfArrayOfTensor6 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(238,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTime out,

               const Var::ArrayOfArrayOfTime in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTime since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTime since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(239,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTransmissionMatrix out,

               const Var::ArrayOfArrayOfTransmissionMatrix in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(240,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfVector out,

               const Var::ArrayOfArrayOfVector in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfVector since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfVector since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(241,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfCIARecord out,

               const Var::ArrayOfCIARecord in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfCIARecord since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfCIARecord since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(242,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField1 out,

               const Var::ArrayOfGriddedField1 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField1 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField1 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(243,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField2 out,

               const Var::ArrayOfGriddedField2 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField2 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField2 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(244,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField3 out,

               const Var::ArrayOfGriddedField3 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(245,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField4 out,

               const Var::ArrayOfGriddedField4 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField4 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField4 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(246,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfIndex out,

               const Var::ArrayOfIndex in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(247,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfMatrix out,

               const Var::ArrayOfMatrix in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfMatrix since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(248,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfPropagationMatrix out,

               const Var::ArrayOfPropagationMatrix in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPropagationMatrix since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPropagationMatrix since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(249,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfQuantumIdentifier out,

               const Var::ArrayOfQuantumIdentifier in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(250,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfRadiationVector out,

               const Var::ArrayOfRadiationVector in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRadiationVector since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRadiationVector since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(251,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfRetrievalQuantity out,

               const Var::ArrayOfRetrievalQuantity in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(252,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfScatteringMetaData out,

               const Var::ArrayOfScatteringMetaData in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfScatteringMetaData since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfScatteringMetaData since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(253,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSingleScatteringData out,

               const Var::ArrayOfSingleScatteringData in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSingleScatteringData since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(254,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSparse out,

               const Var::ArrayOfSparse in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSparse since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSparse since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(255,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfStokesVector out,

               const Var::ArrayOfStokesVector in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfStokesVector since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfStokesVector since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(256,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfString out,

               const Var::ArrayOfString in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfString since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfString since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(257,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTelsemAtlas out,

               const Var::ArrayOfTelsemAtlas in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTelsemAtlas since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTelsemAtlas since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(258,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor3 out,

               const Var::ArrayOfTensor3 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor3 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor3 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(259,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor4 out,

               const Var::ArrayOfTensor4 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor4 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor4 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(260,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor5 out,

               const Var::ArrayOfTensor5 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor5 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor5 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(261,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor6 out,

               const Var::ArrayOfTensor6 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor6 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor6 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(262,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor7 out,

               const Var::ArrayOfTensor7 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor7 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor7 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(263,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTime out,

               const Var::ArrayOfTime in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTime since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTime since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(264,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTransmissionMatrix out,

               const Var::ArrayOfTransmissionMatrix in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(265,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfVector out,

               const Var::ArrayOfVector in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfVector since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(266,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfXsecRecord out,

               const Var::ArrayOfXsecRecord in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfXsecRecord since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfXsecRecord since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(267,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfAbsorptionLines out,

               const Var::AbsorptionLines in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAbsorptionLines since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAbsorptionLines since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(268,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfAbsorptionLines out,

               const Var::ArrayOfAbsorptionLines in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAbsorptionLines since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(269,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfAgenda out,

               const Var::Agenda in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAgenda since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAgenda since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(270,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField1 out,

               const Var::ArrayOfGriddedField1 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField1 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(271,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField2 out,

               const Var::ArrayOfGriddedField2 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField2 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(272,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField3 out,

               const Var::ArrayOfGriddedField3 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(273,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfIndex out,

               const Var::ArrayOfIndex in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfIndex since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(274,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfMatrix out,

               const Var::ArrayOfMatrix in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(275,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfPpath out,

               const Var::Ppath in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPpath since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePpath since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(276,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfPropagationMatrix out,

               const Var::ArrayOfPropagationMatrix in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPropagationMatrix since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(277,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfRadiationVector out,

               const Var::ArrayOfRadiationVector in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRadiationVector since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(278,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfScatteringMetaData out,

               const Var::ArrayOfScatteringMetaData in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfScatteringMetaData since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(279,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfSingleScatteringData out,

               const Var::ArrayOfSingleScatteringData in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSingleScatteringData since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(280,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfStokesVector out,

               const Var::ArrayOfStokesVector in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfStokesVector since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(281,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfString out,

               const Var::ArrayOfString in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfString since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfString since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(282,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTensor3 out,

               const Var::ArrayOfTensor3 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor3 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(283,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTensor6 out,

               const Var::ArrayOfTensor6 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor6 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(284,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTime out,

               const Var::ArrayOfTime in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTime since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTime since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(285,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTransmissionMatrix out,

               const Var::ArrayOfTransmissionMatrix in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(286,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfVector out,

               const Var::ArrayOfVector in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfVector since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfVector since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(287,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfCIARecord out,

               const Var::CIARecord in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfCIARecord since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCIARecord since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(288,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField1 out,

               const Var::GriddedField1 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField1 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField1 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(289,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField2 out,

               const Var::GriddedField2 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField2 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField2 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(290,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField3 out,

               const Var::GriddedField3 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField3 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(291,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField4 out,

               const Var::GriddedField4 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField4 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField4 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(292,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfIndex out,

               const Var::Index in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceIndex since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(293,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfMatrix out,

               const Var::Matrix in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfMatrix since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(294,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfPropagationMatrix out,

               const Var::PropagationMatrix in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPropagationMatrix since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePropagationMatrix since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(295,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfQuantumIdentifier out,

               const Var::QuantumIdentifier in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(296,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfRadiationVector out,

               const Var::RadiationVector in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRadiationVector since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRadiationVector since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(297,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfScatteringMetaData out,

               const Var::ScatteringMetaData in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfScatteringMetaData since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceScatteringMetaData since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(298,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSingleScatteringData out,

               const Var::SingleScatteringData in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSingleScatteringData since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(299,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSparse out,

               const Var::Sparse in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSparse since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSparse since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(300,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfStokesVector out,

               const Var::StokesVector in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfStokesVector since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceStokesVector since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(301,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfString out,

               const Var::String in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfString since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceString since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(302,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTelsemAtlas out,

               const Var::TelsemAtlas in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTelsemAtlas since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTelsemAtlas since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(303,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor3 out,

               const Var::Tensor3 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor3 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(304,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor4 out,

               const Var::Tensor4 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor4 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(305,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor5 out,

               const Var::Tensor5 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor5 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor5 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(306,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor6 out,

               const Var::Tensor6 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor6 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor6 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(307,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor7 out,

               const Var::Tensor7 in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor7 since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor7 since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(308,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTime out,

               const Var::Time in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTime since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTime since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(309,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTransmissionMatrix out,

               const Var::TransmissionMatrix in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTransmissionMatrix since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(310,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Append(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfVector out,

               const Var::Vector in,

               const Var::String& dimension={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of Append");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to Append");

  } if (not dimension.isnull() and dimension.islast()) {

    throw std::runtime_error("dimension needs to be a defined WorkspaceString (or left default) since it is agenda input to Append");

  }


  static const auto dimension_default = Var::StringCreate(ws, "leading",

    "Append_dimension_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(311,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), dimension.isnull() ? Index(dimension_default.pos()) : Group::Index(dimension.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ArrayOfGriddedFieldGetNames(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfString names,

               const Var::ArrayOfGriddedField1 griddedfields) {

  if (names.islast()) {

    throw std::runtime_error("names needs to be a defined WorkspaceArrayOfString since it is output of ArrayOfGriddedFieldGetNames");

  } if (griddedfields.islast()) {

    throw std::runtime_error("griddedfields needs to be a defined WorkspaceArrayOfGriddedField1 since it is agenda input to ArrayOfGriddedFieldGetNames");

  }


  return MRecord(312,

    Group::ArrayOfIndex({Group::Index(names.pos()), }),

    Group::ArrayOfIndex({Group::Index(griddedfields.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ArrayOfGriddedFieldGetNames(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfString names,

               const Var::ArrayOfGriddedField2 griddedfields) {

  if (names.islast()) {

    throw std::runtime_error("names needs to be a defined WorkspaceArrayOfString since it is output of ArrayOfGriddedFieldGetNames");

  } if (griddedfields.islast()) {

    throw std::runtime_error("griddedfields needs to be a defined WorkspaceArrayOfGriddedField2 since it is agenda input to ArrayOfGriddedFieldGetNames");

  }


  return MRecord(313,

    Group::ArrayOfIndex({Group::Index(names.pos()), }),

    Group::ArrayOfIndex({Group::Index(griddedfields.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ArrayOfGriddedFieldGetNames(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfString names,

               const Var::ArrayOfGriddedField3 griddedfields) {

  if (names.islast()) {

    throw std::runtime_error("names needs to be a defined WorkspaceArrayOfString since it is output of ArrayOfGriddedFieldGetNames");

  } if (griddedfields.islast()) {

    throw std::runtime_error("griddedfields needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to ArrayOfGriddedFieldGetNames");

  }


  return MRecord(314,

    Group::ArrayOfIndex({Group::Index(names.pos()), }),

    Group::ArrayOfIndex({Group::Index(griddedfields.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ArrayOfGriddedFieldGetNames(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfString names,

               const Var::ArrayOfGriddedField4 griddedfields) {

  if (names.islast()) {

    throw std::runtime_error("names needs to be a defined WorkspaceArrayOfString since it is output of ArrayOfGriddedFieldGetNames");

  } if (griddedfields.islast()) {

    throw std::runtime_error("griddedfields needs to be a defined WorkspaceArrayOfGriddedField4 since it is agenda input to ArrayOfGriddedFieldGetNames");

  }


  return MRecord(315,

    Group::ArrayOfIndex({Group::Index(names.pos()), }),

    Group::ArrayOfIndex({Group::Index(griddedfields.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ArrayOfIndexLinSpace(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfIndex out,

               const Var::Index start,

               const Var::Index stop,

               const Var::Index step) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of ArrayOfIndexLinSpace");

  } if (start.islast()) {

    throw std::runtime_error("start needs to be a defined WorkspaceIndex since it is agenda input to ArrayOfIndexLinSpace");

  } if (stop.islast()) {

    throw std::runtime_error("stop needs to be a defined WorkspaceIndex since it is agenda input to ArrayOfIndexLinSpace");

  } if (step.islast()) {

    throw std::runtime_error("step needs to be a defined WorkspaceIndex since it is agenda input to ArrayOfIndexLinSpace");

  }


  return MRecord(316,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(start.pos()), Group::Index(stop.pos()), Group::Index(step.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ArrayOfIndexSet(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfIndex out,

               const Var::ArrayOfIndex value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of ArrayOfIndexSet");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceArrayOfIndex since it is agenda input to ArrayOfIndexSet");

  }


  return MRecord(317,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(value.pos()), }),

    TokVal{value.value()}, Agenda{});

}


[[nodiscard]] inline

MRecord ArrayOfIndexSetConstant(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfIndex out,

               const Var::Index value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of ArrayOfIndexSetConstant");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceIndex since it is agenda input to ArrayOfIndexSetConstant");

  }


  return MRecord(318,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({183, Group::Index(value.pos()), }),

    TokVal{value.value()}, Agenda{});

}


[[nodiscard]] inline

MRecord ArrayOfStringSet(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfString out,

               const Var::ArrayOfString value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfString since it is output of ArrayOfStringSet");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceArrayOfString since it is agenda input to ArrayOfStringSet");

  }


  return MRecord(319,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(value.pos()), }),

    TokVal{value.value()}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmFieldPerturb(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 perturbed_field,

               const Var::Tensor3 original_field,

               const Var::Vector p_ret_grid,

               const Var::Vector lat_ret_grid,

               const Var::Vector lon_ret_grid,

               const Var::Index pert_index,

               const Var::Numeric pert_size,

               const Var::String& pert_mode={}) {

  if (perturbed_field.islast()) {

    throw std::runtime_error("perturbed_field needs to be a defined WorkspaceTensor3 since it is output of AtmFieldPerturb");

  } if (original_field.islast()) {

    throw std::runtime_error("original_field needs to be a defined WorkspaceTensor3 since it is agenda input to AtmFieldPerturb");

  } if (p_ret_grid.islast()) {

    throw std::runtime_error("p_ret_grid needs to be a defined WorkspaceVector since it is agenda input to AtmFieldPerturb");

  } if (lat_ret_grid.islast()) {

    throw std::runtime_error("lat_ret_grid needs to be a defined WorkspaceVector since it is agenda input to AtmFieldPerturb");

  } if (lon_ret_grid.islast()) {

    throw std::runtime_error("lon_ret_grid needs to be a defined WorkspaceVector since it is agenda input to AtmFieldPerturb");

  } if (pert_index.islast()) {

    throw std::runtime_error("pert_index needs to be a defined WorkspaceIndex since it is agenda input to AtmFieldPerturb");

  } if (pert_size.islast()) {

    throw std::runtime_error("pert_size needs to be a defined WorkspaceNumeric since it is agenda input to AtmFieldPerturb");

  } if (not pert_mode.isnull() and pert_mode.islast()) {

    throw std::runtime_error("pert_mode needs to be a defined WorkspaceString (or left default) since it is agenda input to AtmFieldPerturb");

  }


  static const auto pert_mode_default = Var::StringCreate(ws, "absolute",

    "AtmFieldPerturb_pert_mode_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(322,

    Group::ArrayOfIndex({Group::Index(perturbed_field.pos()), }),

    Group::ArrayOfIndex({35, 242, 139, 147, Group::Index(original_field.pos()), Group::Index(p_ret_grid.pos()), Group::Index(lat_ret_grid.pos()), Group::Index(lon_ret_grid.pos()), Group::Index(pert_index.pos()), Group::Index(pert_size.pos()), pert_mode.isnull() ? Index(pert_mode_default.pos()) : Group::Index(pert_mode.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmFieldPerturbAtmGrids(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 perturbed_field,

               const Var::Tensor3 original_field,

               const Var::Index pert_index,

               const Var::Numeric pert_size,

               const Var::String& pert_mode={}) {

  if (perturbed_field.islast()) {

    throw std::runtime_error("perturbed_field needs to be a defined WorkspaceTensor3 since it is output of AtmFieldPerturbAtmGrids");

  } if (original_field.islast()) {

    throw std::runtime_error("original_field needs to be a defined WorkspaceTensor3 since it is agenda input to AtmFieldPerturbAtmGrids");

  } if (pert_index.islast()) {

    throw std::runtime_error("pert_index needs to be a defined WorkspaceIndex since it is agenda input to AtmFieldPerturbAtmGrids");

  } if (pert_size.islast()) {

    throw std::runtime_error("pert_size needs to be a defined WorkspaceNumeric since it is agenda input to AtmFieldPerturbAtmGrids");

  } if (not pert_mode.isnull() and pert_mode.islast()) {

    throw std::runtime_error("pert_mode needs to be a defined WorkspaceString (or left default) since it is agenda input to AtmFieldPerturbAtmGrids");

  }


  static const auto pert_mode_default = Var::StringCreate(ws, "absolute",

    "AtmFieldPerturbAtmGrids_pert_mode_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(323,

    Group::ArrayOfIndex({Group::Index(perturbed_field.pos()), }),

    Group::ArrayOfIndex({35, 242, 139, 147, Group::Index(original_field.pos()), Group::Index(pert_index.pos()), Group::Index(pert_size.pos()), pert_mode.isnull() ? Index(pert_mode_default.pos()) : Group::Index(pert_mode.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmFieldPRegrid(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 out,

               const Var::Tensor3 in,

               const Var::Vector p_grid_new,

               const Var::Vector p_grid_old,

               const Var::Index& interp_order={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of AtmFieldPRegrid");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is agenda input to AtmFieldPRegrid");

  } if (p_grid_new.islast()) {

    throw std::runtime_error("p_grid_new needs to be a defined WorkspaceVector since it is agenda input to AtmFieldPRegrid");

  } if (p_grid_old.islast()) {

    throw std::runtime_error("p_grid_old needs to be a defined WorkspaceVector since it is agenda input to AtmFieldPRegrid");

  } if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldPRegrid");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "AtmFieldPRegrid_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(324,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(p_grid_new.pos()), Group::Index(p_grid_old.pos()), interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmFieldPRegrid(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 out,

               const Var::Tensor4 in,

               const Var::Vector p_grid_new,

               const Var::Vector p_grid_old,

               const Var::Index& interp_order={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of AtmFieldPRegrid");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is agenda input to AtmFieldPRegrid");

  } if (p_grid_new.islast()) {

    throw std::runtime_error("p_grid_new needs to be a defined WorkspaceVector since it is agenda input to AtmFieldPRegrid");

  } if (p_grid_old.islast()) {

    throw std::runtime_error("p_grid_old needs to be a defined WorkspaceVector since it is agenda input to AtmFieldPRegrid");

  } if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldPRegrid");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "AtmFieldPRegrid_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(325,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(p_grid_new.pos()), Group::Index(p_grid_old.pos()), interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmFieldsCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& interp_order={},

               const Var::Index& vmr_zeropadding={},

               const Var::Index& vmr_nonegative={},

               const Var::Index& nlte_when_negative={}) {

  if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldsCalc");

  } if (not vmr_zeropadding.isnull() and vmr_zeropadding.islast()) {

    throw std::runtime_error("vmr_zeropadding needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldsCalc");

  } if (not vmr_nonegative.isnull() and vmr_nonegative.islast()) {

    throw std::runtime_error("vmr_nonegative needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldsCalc");

  } if (not nlte_when_negative.isnull() and nlte_when_negative.islast()) {

    throw std::runtime_error("nlte_when_negative needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldsCalc");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "AtmFieldsCalc_interp_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto vmr_zeropadding_default = Var::IndexCreate(ws, 0,

    "AtmFieldsCalc_vmr_zeropadding_autodefault",

    "auto generated variable with default from method definition");

  static const auto vmr_nonegative_default = Var::IndexCreate(ws, 0,

    "AtmFieldsCalc_vmr_nonegative_autodefault",

    "auto generated variable with default from method definition");

  static const auto nlte_when_negative_default = Var::IndexCreate(ws, 0,

    "AtmFieldsCalc_nlte_when_negative_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(326,

    Group::ArrayOfIndex({338, 381, 344, 339, }),

    Group::ArrayOfIndex({242, 139, 147, 340, 382, 345, 341, 179, 180, 35, interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), vmr_zeropadding.isnull() ? Index(vmr_zeropadding_default.pos()) : Group::Index(vmr_zeropadding.pos()), vmr_nonegative.isnull() ? Index(vmr_nonegative_default.pos()) : Group::Index(vmr_nonegative.pos()), nlte_when_negative.isnull() ? Index(nlte_when_negative_default.pos()) : Group::Index(nlte_when_negative.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmFieldsCalcExpand1D(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& interp_order={},

               const Var::Index& vmr_zeropadding={},

               const Var::Index& vmr_nonegative={},

               const Var::Index& nlte_when_negative={}) {

  if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldsCalcExpand1D");

  } if (not vmr_zeropadding.isnull() and vmr_zeropadding.islast()) {

    throw std::runtime_error("vmr_zeropadding needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldsCalcExpand1D");

  } if (not vmr_nonegative.isnull() and vmr_nonegative.islast()) {

    throw std::runtime_error("vmr_nonegative needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldsCalcExpand1D");

  } if (not nlte_when_negative.isnull() and nlte_when_negative.islast()) {

    throw std::runtime_error("nlte_when_negative needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldsCalcExpand1D");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "AtmFieldsCalcExpand1D_interp_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto vmr_zeropadding_default = Var::IndexCreate(ws, 0,

    "AtmFieldsCalcExpand1D_vmr_zeropadding_autodefault",

    "auto generated variable with default from method definition");

  static const auto vmr_nonegative_default = Var::IndexCreate(ws, 0,

    "AtmFieldsCalcExpand1D_vmr_nonegative_autodefault",

    "auto generated variable with default from method definition");

  static const auto nlte_when_negative_default = Var::IndexCreate(ws, 0,

    "AtmFieldsCalcExpand1D_nlte_when_negative_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(327,

    Group::ArrayOfIndex({338, 381, 344, 339, }),

    Group::ArrayOfIndex({242, 139, 147, 340, 382, 345, 341, 179, 180, 35, interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), vmr_zeropadding.isnull() ? Index(vmr_zeropadding_default.pos()) : Group::Index(vmr_zeropadding.pos()), vmr_nonegative.isnull() ? Index(vmr_nonegative_default.pos()) : Group::Index(vmr_nonegative.pos()), nlte_when_negative.isnull() ? Index(nlte_when_negative_default.pos()) : Group::Index(nlte_when_negative.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmFieldsExpand1D(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& chk_vmr_nan={}) {

  if (not chk_vmr_nan.isnull() and chk_vmr_nan.islast()) {

    throw std::runtime_error("chk_vmr_nan needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldsExpand1D");

  }


  static const auto chk_vmr_nan_default = Var::IndexCreate(ws, 1,

    "AtmFieldsExpand1D_chk_vmr_nan_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(328,

    Group::ArrayOfIndex({338, 381, 344, }),

    Group::ArrayOfIndex({242, 139, 147, 35, chk_vmr_nan.isnull() ? Index(chk_vmr_nan_default.pos()) : Group::Index(chk_vmr_nan.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmFieldsExtract1D(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& ilat={},

               const Var::Index& ilon={}) {

  if (not ilat.isnull() and ilat.islast()) {

    throw std::runtime_error("ilat needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldsExtract1D");

  } if (not ilon.isnull() and ilon.islast()) {

    throw std::runtime_error("ilon needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldsExtract1D");

  }


  static const auto ilat_default = Var::IndexCreate(ws, 0,

    "AtmFieldsExtract1D_ilat_autodefault",

    "auto generated variable with default from method definition");

  static const auto ilon_default = Var::IndexCreate(ws, 0,

    "AtmFieldsExtract1D_ilon_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(329,

    Group::ArrayOfIndex({35, 139, 147, 338, 381, 344, }),

    Group::ArrayOfIndex({ilat.isnull() ? Index(ilat_default.pos()) : Group::Index(ilat.pos()), ilon.isnull() ? Index(ilon_default.pos()) : Group::Index(ilon.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmFieldsRefinePgrid(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric p_step,

               const Var::Index& interp_order={}) {

  if (p_step.islast()) {

    throw std::runtime_error("p_step needs to be a defined WorkspaceNumeric since it is agenda input to AtmFieldsRefinePgrid");

  } if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldsRefinePgrid");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "AtmFieldsRefinePgrid_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(330,

    Group::ArrayOfIndex({242, 338, 381, 344, 36, 37, 48, }),

    Group::ArrayOfIndex({139, 147, 35, Group::Index(p_step.pos()), interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmFieldsAndParticleBulkPropFieldFromCompact(

    [[maybe_unused]] Workspace& ws,

               const Var::String& delim={},

               const Var::Numeric& p_min={},

               const Var::Index& check_gridnames={}) {

  if (not delim.isnull() and delim.islast()) {

    throw std::runtime_error("delim needs to be a defined WorkspaceString (or left default) since it is agenda input to AtmFieldsAndParticleBulkPropFieldFromCompact");

  } if (not p_min.isnull() and p_min.islast()) {

    throw std::runtime_error("p_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to AtmFieldsAndParticleBulkPropFieldFromCompact");

  } if (not check_gridnames.isnull() and check_gridnames.islast()) {

    throw std::runtime_error("check_gridnames needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmFieldsAndParticleBulkPropFieldFromCompact");

  }


  static const auto delim_default = Var::StringCreate(ws, "-",

    "AtmFieldsAndParticleBulkPropFieldFromCompact_delim_autodefault",

    "auto generated variable with default from method definition");

  static const auto p_min_default = Var::NumericCreate(ws, 0,

    "AtmFieldsAndParticleBulkPropFieldFromCompact_p_min_autodefault",

    "auto generated variable with default from method definition");

  static const auto check_gridnames_default = Var::IndexCreate(ws, 0,

    "AtmFieldsAndParticleBulkPropFieldFromCompact_check_gridnames_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(331,

    Group::ArrayOfIndex({242, 139, 147, 338, 381, 344, 197, 198, }),

    Group::ArrayOfIndex({21, 38, 35, delim.isnull() ? Index(delim_default.pos()) : Group::Index(delim.pos()), p_min.isnull() ? Index(p_min_default.pos()) : Group::Index(p_min.pos()), check_gridnames.isnull() ? Index(check_gridnames_default.pos()) : Group::Index(check_gridnames.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord atmfields_checkedCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& negative_vmr_ok={},

               const Var::Index& bad_partition_functions_ok={}) {

  if (not negative_vmr_ok.isnull() and negative_vmr_ok.islast()) {

    throw std::runtime_error("negative_vmr_ok needs to be a defined WorkspaceIndex (or left default) since it is agenda input to atmfields_checkedCalc");

  } if (not bad_partition_functions_ok.isnull() and bad_partition_functions_ok.islast()) {

    throw std::runtime_error("bad_partition_functions_ok needs to be a defined WorkspaceIndex (or left default) since it is agenda input to atmfields_checkedCalc");

  }


  static const auto negative_vmr_ok_default = Var::IndexCreate(ws, 0,

    "atmfields_checkedCalc_negative_vmr_ok_autodefault",

    "auto generated variable with default from method definition");

  static const auto bad_partition_functions_ok_default = Var::IndexCreate(ws, 0,

    "atmfields_checkedCalc_bad_partition_functions_ok_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(332,

    Group::ArrayOfIndex({36, }),

    Group::ArrayOfIndex({35, 242, 139, 147, 21, 338, 344, 349, 351, 353, 149, 151, 153, 200, 8, negative_vmr_ok.isnull() ? Index(negative_vmr_ok_default.pos()) : Group::Index(negative_vmr_ok.pos()), bad_partition_functions_ok.isnull() ? Index(bad_partition_functions_ok_default.pos()) : Group::Index(bad_partition_functions_ok.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord atmgeom_checkedCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(333,

    Group::ArrayOfIndex({37, }),

    Group::ArrayOfIndex({35, 242, 139, 147, 381, 250, 384, 140, 148, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmosphereSet1D(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(334,

    Group::ArrayOfIndex({35, 139, 147, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmosphereSet2D(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(335,

    Group::ArrayOfIndex({35, 147, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmosphereSet3D(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(336,

    Group::ArrayOfIndex({35, 140, 148, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmRawRead(

    [[maybe_unused]] Workspace& ws,

               const Var::String basename) {

  if (basename.islast()) {

    throw std::runtime_error("basename needs to be a defined WorkspaceString since it is agenda input to AtmRawRead");

  }


  return MRecord(337,

    Group::ArrayOfIndex({340, 382, 345, 341, 179, 180, }),

    Group::ArrayOfIndex({21, Group::Index(basename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord AtmWithNLTERawRead(

    [[maybe_unused]] Workspace& ws,

               const Var::String basename,

               const Var::Index& expect_vibrational_energies={}) {

  if (basename.islast()) {

    throw std::runtime_error("basename needs to be a defined WorkspaceString since it is agenda input to AtmWithNLTERawRead");

  } if (not expect_vibrational_energies.isnull() and expect_vibrational_energies.islast()) {

    throw std::runtime_error("expect_vibrational_energies needs to be a defined WorkspaceIndex (or left default) since it is agenda input to AtmWithNLTERawRead");

  }


  static const auto expect_vibrational_energies_default = Var::IndexCreate(ws, 0,

    "AtmWithNLTERawRead_expect_vibrational_energies_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(338,

    Group::ArrayOfIndex({340, 382, 345, 341, 179, 180, }),

    Group::ArrayOfIndex({21, Group::Index(basename.pos()), expect_vibrational_energies.isnull() ? Index(expect_vibrational_energies_default.pos()) : Group::Index(expect_vibrational_energies.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord atm_fields_compactAddConstant(

    [[maybe_unused]] Workspace& ws,

               const Var::String name,

               const Var::Numeric value,

               const Var::Index& prepend={},

               const Var::ArrayOfString& condensibles={}) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is agenda input to atm_fields_compactAddConstant");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to atm_fields_compactAddConstant");

  } if (not prepend.isnull() and prepend.islast()) {

    throw std::runtime_error("prepend needs to be a defined WorkspaceIndex (or left default) since it is agenda input to atm_fields_compactAddConstant");

  } if (not condensibles.isnull() and condensibles.islast()) {

    throw std::runtime_error("condensibles needs to be a defined WorkspaceArrayOfString (or left default) since it is agenda input to atm_fields_compactAddConstant");

  }


  static const auto prepend_default = Var::IndexCreate(ws, 0,

    "atm_fields_compactAddConstant_prepend_autodefault",

    "auto generated variable with default from method definition");

  static const auto condensibles_default = Var::ArrayOfStringCreate(ws, {},

    "atm_fields_compactAddConstant_condensibles_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(339,

    Group::ArrayOfIndex({38, }),

    Group::ArrayOfIndex({Group::Index(name.pos()), Group::Index(value.pos()), prepend.isnull() ? Index(prepend_default.pos()) : Group::Index(prepend.pos()), condensibles.isnull() ? Index(condensibles_default.pos()) : Group::Index(condensibles.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord atm_fields_compactAddSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::String name,

               const Var::GriddedField3 value,

               const Var::Index& prepend={}) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is agenda input to atm_fields_compactAddSpecies");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceGriddedField3 since it is agenda input to atm_fields_compactAddSpecies");

  } if (not prepend.isnull() and prepend.islast()) {

    throw std::runtime_error("prepend needs to be a defined WorkspaceIndex (or left default) since it is agenda input to atm_fields_compactAddSpecies");

  }


  static const auto prepend_default = Var::IndexCreate(ws, 0,

    "atm_fields_compactAddSpecies_prepend_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(340,

    Group::ArrayOfIndex({38, }),

    Group::ArrayOfIndex({Group::Index(name.pos()), Group::Index(value.pos()), prepend.isnull() ? Index(prepend_default.pos()) : Group::Index(prepend.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord atm_fields_compactCleanup(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric threshold) {

  if (threshold.islast()) {

    throw std::runtime_error("threshold needs to be a defined WorkspaceNumeric since it is agenda input to atm_fields_compactCleanup");

  }


  return MRecord(341,

    Group::ArrayOfIndex({38, }),

    Group::ArrayOfIndex({Group::Index(threshold.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord atm_fields_compactCreateFromField(

    [[maybe_unused]] Workspace& ws,

               const Var::String name,

               const Var::GriddedField3 field) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is agenda input to atm_fields_compactCreateFromField");

  } if (field.islast()) {

    throw std::runtime_error("field needs to be a defined WorkspaceGriddedField3 since it is agenda input to atm_fields_compactCreateFromField");

  }


  return MRecord(342,

    Group::ArrayOfIndex({38, }),

    Group::ArrayOfIndex({Group::Index(name.pos()), Group::Index(field.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord atm_fields_compactFromMatrix(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix gin1,

               const Var::ArrayOfString field_names) {

  if (gin1.islast()) {

    throw std::runtime_error("gin1 needs to be a defined WorkspaceMatrix since it is agenda input to atm_fields_compactFromMatrix");

  } if (field_names.islast()) {

    throw std::runtime_error("field_names needs to be a defined WorkspaceArrayOfString since it is agenda input to atm_fields_compactFromMatrix");

  }


  return MRecord(343,

    Group::ArrayOfIndex({38, }),

    Group::ArrayOfIndex({35, Group::Index(gin1.pos()), Group::Index(field_names.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord backend_channel_responseFlat(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric resolution) {

  if (resolution.islast()) {

    throw std::runtime_error("resolution needs to be a defined WorkspaceNumeric since it is agenda input to backend_channel_responseFlat");

  }


  return MRecord(344,

    Group::ArrayOfIndex({40, }),

    Group::ArrayOfIndex({Group::Index(resolution.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord backend_channel_responseGaussian(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector fwhm,

               const Var::Vector& xwidth_si={},

               const Var::Vector& dx_si={}) {

  if (fwhm.islast()) {

    throw std::runtime_error("fwhm needs to be a defined WorkspaceVector since it is agenda input to backend_channel_responseGaussian");

  } if (not xwidth_si.isnull() and xwidth_si.islast()) {

    throw std::runtime_error("xwidth_si needs to be a defined WorkspaceVector (or left default) since it is agenda input to backend_channel_responseGaussian");

  } if (not dx_si.isnull() and dx_si.islast()) {

    throw std::runtime_error("dx_si needs to be a defined WorkspaceVector (or left default) since it is agenda input to backend_channel_responseGaussian");

  }


  static const auto xwidth_si_default = Var::VectorCreate(ws, {3},

    "backend_channel_responseGaussian_xwidth_si_autodefault",

    "auto generated variable with default from method definition");

  static const auto dx_si_default = Var::VectorCreate(ws, {0.1},

    "backend_channel_responseGaussian_dx_si_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(345,

    Group::ArrayOfIndex({40, }),

    Group::ArrayOfIndex({Group::Index(fwhm.pos()), xwidth_si.isnull() ? Index(xwidth_si_default.pos()) : Group::Index(xwidth_si.pos()), dx_si.isnull() ? Index(dx_si_default.pos()) : Group::Index(dx_si.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord batch_atm_fields_compactAddConstant(

    [[maybe_unused]] Workspace& ws,

               const Var::String name,

               const Var::Numeric value,

               const Var::Index& prepend={},

               const Var::ArrayOfString& condensibles={}) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is agenda input to batch_atm_fields_compactAddConstant");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to batch_atm_fields_compactAddConstant");

  } if (not prepend.isnull() and prepend.islast()) {

    throw std::runtime_error("prepend needs to be a defined WorkspaceIndex (or left default) since it is agenda input to batch_atm_fields_compactAddConstant");

  } if (not condensibles.isnull() and condensibles.islast()) {

    throw std::runtime_error("condensibles needs to be a defined WorkspaceArrayOfString (or left default) since it is agenda input to batch_atm_fields_compactAddConstant");

  }


  static const auto prepend_default = Var::IndexCreate(ws, 0,

    "batch_atm_fields_compactAddConstant_prepend_autodefault",

    "auto generated variable with default from method definition");

  static const auto condensibles_default = Var::ArrayOfStringCreate(ws, {},

    "batch_atm_fields_compactAddConstant_condensibles_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(346,

    Group::ArrayOfIndex({42, }),

    Group::ArrayOfIndex({Group::Index(name.pos()), Group::Index(value.pos()), prepend.isnull() ? Index(prepend_default.pos()) : Group::Index(prepend.pos()), condensibles.isnull() ? Index(condensibles_default.pos()) : Group::Index(condensibles.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord batch_atm_fields_compactAddSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::String name,

               const Var::GriddedField3 value,

               const Var::Index& prepend={}) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is agenda input to batch_atm_fields_compactAddSpecies");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceGriddedField3 since it is agenda input to batch_atm_fields_compactAddSpecies");

  } if (not prepend.isnull() and prepend.islast()) {

    throw std::runtime_error("prepend needs to be a defined WorkspaceIndex (or left default) since it is agenda input to batch_atm_fields_compactAddSpecies");

  }


  static const auto prepend_default = Var::IndexCreate(ws, 0,

    "batch_atm_fields_compactAddSpecies_prepend_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(347,

    Group::ArrayOfIndex({42, }),

    Group::ArrayOfIndex({Group::Index(name.pos()), Group::Index(value.pos()), prepend.isnull() ? Index(prepend_default.pos()) : Group::Index(prepend.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord batch_atm_fields_compactCleanup(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric threshold) {

  if (threshold.islast()) {

    throw std::runtime_error("threshold needs to be a defined WorkspaceNumeric since it is agenda input to batch_atm_fields_compactCleanup");

  }


  return MRecord(348,

    Group::ArrayOfIndex({42, }),

    Group::ArrayOfIndex({Group::Index(threshold.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord batch_atm_fields_compactFromArrayOfMatrix(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfMatrix atmospheres_fields,

               const Var::ArrayOfString field_names) {

  if (atmospheres_fields.islast()) {

    throw std::runtime_error("atmospheres_fields needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to batch_atm_fields_compactFromArrayOfMatrix");

  } if (field_names.islast()) {

    throw std::runtime_error("field_names needs to be a defined WorkspaceArrayOfString since it is agenda input to batch_atm_fields_compactFromArrayOfMatrix");

  }


  return MRecord(349,

    Group::ArrayOfIndex({42, }),

    Group::ArrayOfIndex({35, Group::Index(atmospheres_fields.pos()), Group::Index(field_names.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CIAInfo(

    [[maybe_unused]] Workspace& ws,

               const Var::String catalogpath,

               const Var::ArrayOfString cia_tags) {

  if (catalogpath.islast()) {

    throw std::runtime_error("catalogpath needs to be a defined WorkspaceString since it is agenda input to CIAInfo");

  } if (cia_tags.islast()) {

    throw std::runtime_error("cia_tags needs to be a defined WorkspaceArrayOfString since it is agenda input to CIAInfo");

  }


  return MRecord(350,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(catalogpath.pos()), Group::Index(cia_tags.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CIARecordReadFromFile(

    [[maybe_unused]] Workspace& ws,

                     Var::CIARecord cia_record,

               const Var::String species_tag,

               const Var::String filename) {

  if (cia_record.islast()) {

    throw std::runtime_error("cia_record needs to be a defined WorkspaceCIARecord since it is output of CIARecordReadFromFile");

  } if (species_tag.islast()) {

    throw std::runtime_error("species_tag needs to be a defined WorkspaceString since it is agenda input to CIARecordReadFromFile");

  } if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to CIARecordReadFromFile");

  }


  return MRecord(351,

    Group::ArrayOfIndex({Group::Index(cia_record.pos()), }),

    Group::ArrayOfIndex({Group::Index(species_tag.pos()), Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudboxOff(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(352,

    Group::ArrayOfIndex({53, 219, 52, 123, 213, 75, 277, 267, 269, 268, 199, }),

    Group::ArrayOfIndex({137, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudboxSetAutomatically(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 particle_field,

               const Var::ArrayOfIndex& cloudbox_limits_old={},

               const Var::Numeric& cloudbox_margin={}) {

  if (particle_field.islast()) {

    throw std::runtime_error("particle_field needs to be a defined WorkspaceTensor4 since it is agenda input to cloudboxSetAutomatically");

  } if (not cloudbox_limits_old.isnull() and cloudbox_limits_old.islast()) {

    throw std::runtime_error("cloudbox_limits_old needs to be a defined WorkspaceArrayOfIndex (or left default) since it is agenda input to cloudboxSetAutomatically");

  } if (not cloudbox_margin.isnull() and cloudbox_margin.islast()) {

    throw std::runtime_error("cloudbox_margin needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to cloudboxSetAutomatically");

  }


  static const auto cloudbox_limits_old_default = Var::ArrayOfIndexCreate(ws, {-1},

    "cloudboxSetAutomatically_cloudbox_limits_old_autodefault",

    "auto generated variable with default from method definition");

  static const auto cloudbox_margin_default = Var::NumericCreate(ws, -1,

    "cloudboxSetAutomatically_cloudbox_margin_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(353,

    Group::ArrayOfIndex({53, 52, }),

    Group::ArrayOfIndex({35, 242, 139, 147, Group::Index(particle_field.pos()), cloudbox_limits_old.isnull() ? Index(cloudbox_limits_old_default.pos()) : Group::Index(cloudbox_limits_old.pos()), cloudbox_margin.isnull() ? Index(cloudbox_margin_default.pos()) : Group::Index(cloudbox_margin.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudboxSetFullAtm(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(354,

    Group::ArrayOfIndex({53, 52, }),

    Group::ArrayOfIndex({35, 242, 139, 147, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudboxSetManually(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric p1,

               const Var::Numeric p2,

               const Var::Numeric lat1,

               const Var::Numeric lat2,

               const Var::Numeric lon1,

               const Var::Numeric lon2) {

  if (p1.islast()) {

    throw std::runtime_error("p1 needs to be a defined WorkspaceNumeric since it is agenda input to cloudboxSetManually");

  } if (p2.islast()) {

    throw std::runtime_error("p2 needs to be a defined WorkspaceNumeric since it is agenda input to cloudboxSetManually");

  } if (lat1.islast()) {

    throw std::runtime_error("lat1 needs to be a defined WorkspaceNumeric since it is agenda input to cloudboxSetManually");

  } if (lat2.islast()) {

    throw std::runtime_error("lat2 needs to be a defined WorkspaceNumeric since it is agenda input to cloudboxSetManually");

  } if (lon1.islast()) {

    throw std::runtime_error("lon1 needs to be a defined WorkspaceNumeric since it is agenda input to cloudboxSetManually");

  } if (lon2.islast()) {

    throw std::runtime_error("lon2 needs to be a defined WorkspaceNumeric since it is agenda input to cloudboxSetManually");

  }


  return MRecord(355,

    Group::ArrayOfIndex({53, 52, }),

    Group::ArrayOfIndex({35, 242, 139, 147, Group::Index(p1.pos()), Group::Index(p2.pos()), Group::Index(lat1.pos()), Group::Index(lat2.pos()), Group::Index(lon1.pos()), Group::Index(lon2.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudboxSetManuallyAltitude(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric z1,

               const Var::Numeric z2,

               const Var::Numeric lat1,

               const Var::Numeric lat2,

               const Var::Numeric lon1,

               const Var::Numeric lon2) {

  if (z1.islast()) {

    throw std::runtime_error("z1 needs to be a defined WorkspaceNumeric since it is agenda input to cloudboxSetManuallyAltitude");

  } if (z2.islast()) {

    throw std::runtime_error("z2 needs to be a defined WorkspaceNumeric since it is agenda input to cloudboxSetManuallyAltitude");

  } if (lat1.islast()) {

    throw std::runtime_error("lat1 needs to be a defined WorkspaceNumeric since it is agenda input to cloudboxSetManuallyAltitude");

  } if (lat2.islast()) {

    throw std::runtime_error("lat2 needs to be a defined WorkspaceNumeric since it is agenda input to cloudboxSetManuallyAltitude");

  } if (lon1.islast()) {

    throw std::runtime_error("lon1 needs to be a defined WorkspaceNumeric since it is agenda input to cloudboxSetManuallyAltitude");

  } if (lon2.islast()) {

    throw std::runtime_error("lon2 needs to be a defined WorkspaceNumeric since it is agenda input to cloudboxSetManuallyAltitude");

  }


  return MRecord(356,

    Group::ArrayOfIndex({53, 52, }),

    Group::ArrayOfIndex({35, 381, 139, 147, Group::Index(z1.pos()), Group::Index(z2.pos()), Group::Index(lat1.pos()), Group::Index(lat2.pos()), Group::Index(lon1.pos()), Group::Index(lon2.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudbox_checkedCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& negative_pnd_ok={}) {

  if (not negative_pnd_ok.isnull() and negative_pnd_ok.islast()) {

    throw std::runtime_error("negative_pnd_ok needs to be a defined WorkspaceIndex (or left default) since it is agenda input to cloudbox_checkedCalc");

  }


  static const auto negative_pnd_ok_default = Var::IndexCreate(ws, 0,

    "cloudbox_checkedCalc_negative_pnd_ok_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(357,

    Group::ArrayOfIndex({48, }),

    Group::ArrayOfIndex({36, 35, 242, 139, 147, 381, 384, 349, 351, 353, 53, 52, 213, 75, 137, 267, 277, 199, 21, negative_pnd_ok.isnull() ? Index(negative_pnd_ok_default.pos()) : Group::Index(negative_pnd_ok.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudbox_field_monoIterate(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& accelerated={}) {

  if (not accelerated.isnull() and accelerated.islast()) {

    throw std::runtime_error("accelerated needs to be a defined WorkspaceIndex (or left default) since it is agenda input to cloudbox_field_monoIterate");

  }


  static const auto accelerated_default = Var::IndexCreate(ws, 0,

    "cloudbox_field_monoIterate_accelerated_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(358,

    Group::ArrayOfIndex({50, }),

    Group::ArrayOfIndex({86, 85, 81, accelerated.isnull() ? Index(accelerated_default.pos()) : Group::Index(accelerated.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudbox_fieldCrop(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& new_limit0={},

               const Var::Index& new_limit1={},

               const Var::Index& new_limit2={},

               const Var::Index& new_limit3={},

               const Var::Index& new_limit4={},

               const Var::Index& new_limit5={}) {

  if (not new_limit0.isnull() and new_limit0.islast()) {

    throw std::runtime_error("new_limit0 needs to be a defined WorkspaceIndex (or left default) since it is agenda input to cloudbox_fieldCrop");

  } if (not new_limit1.isnull() and new_limit1.islast()) {

    throw std::runtime_error("new_limit1 needs to be a defined WorkspaceIndex (or left default) since it is agenda input to cloudbox_fieldCrop");

  } if (not new_limit2.isnull() and new_limit2.islast()) {

    throw std::runtime_error("new_limit2 needs to be a defined WorkspaceIndex (or left default) since it is agenda input to cloudbox_fieldCrop");

  } if (not new_limit3.isnull() and new_limit3.islast()) {

    throw std::runtime_error("new_limit3 needs to be a defined WorkspaceIndex (or left default) since it is agenda input to cloudbox_fieldCrop");

  } if (not new_limit4.isnull() and new_limit4.islast()) {

    throw std::runtime_error("new_limit4 needs to be a defined WorkspaceIndex (or left default) since it is agenda input to cloudbox_fieldCrop");

  } if (not new_limit5.isnull() and new_limit5.islast()) {

    throw std::runtime_error("new_limit5 needs to be a defined WorkspaceIndex (or left default) since it is agenda input to cloudbox_fieldCrop");

  }


  static const auto new_limit0_default = Var::IndexCreate(ws, 0,

    "cloudbox_fieldCrop_new_limit0_autodefault",

    "auto generated variable with default from method definition");

  static const auto new_limit1_default = Var::IndexCreate(ws, 0,

    "cloudbox_fieldCrop_new_limit1_autodefault",

    "auto generated variable with default from method definition");

  static const auto new_limit2_default = Var::IndexCreate(ws, 0,

    "cloudbox_fieldCrop_new_limit2_autodefault",

    "auto generated variable with default from method definition");

  static const auto new_limit3_default = Var::IndexCreate(ws, 0,

    "cloudbox_fieldCrop_new_limit3_autodefault",

    "auto generated variable with default from method definition");

  static const auto new_limit4_default = Var::IndexCreate(ws, 0,

    "cloudbox_fieldCrop_new_limit4_autodefault",

    "auto generated variable with default from method definition");

  static const auto new_limit5_default = Var::IndexCreate(ws, 0,

    "cloudbox_fieldCrop_new_limit5_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(359,

    Group::ArrayOfIndex({49, 52, }),

    Group::ArrayOfIndex({35, 53, new_limit0.isnull() ? Index(new_limit0_default.pos()) : Group::Index(new_limit0.pos()), new_limit1.isnull() ? Index(new_limit1_default.pos()) : Group::Index(new_limit1.pos()), new_limit2.isnull() ? Index(new_limit2_default.pos()) : Group::Index(new_limit2.pos()), new_limit3.isnull() ? Index(new_limit3_default.pos()) : Group::Index(new_limit3.pos()), new_limit4.isnull() ? Index(new_limit4_default.pos()) : Group::Index(new_limit4.pos()), new_limit5.isnull() ? Index(new_limit5_default.pos()) : Group::Index(new_limit5.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudbox_fieldSetFromPrecalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 cloudbox_field_precalc) {

  if (cloudbox_field_precalc.islast()) {

    throw std::runtime_error("cloudbox_field_precalc needs to be a defined WorkspaceTensor7 since it is agenda input to cloudbox_fieldSetFromPrecalc");

  }


  return MRecord(360,

    Group::ArrayOfIndex({49, }),

    Group::ArrayOfIndex({378, 104, 35, 306, 52, 82, Group::Index(cloudbox_field_precalc.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudbox_fieldSetClearsky(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& all_frequencies={}) {

  if (not all_frequencies.isnull() and all_frequencies.islast()) {

    throw std::runtime_error("all_frequencies needs to be a defined WorkspaceIndex (or left default) since it is agenda input to cloudbox_fieldSetClearsky");

  }


  static const auto all_frequencies_default = Var::IndexCreate(ws, 1,

    "cloudbox_fieldSetClearsky_all_frequencies_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(361,

    Group::ArrayOfIndex({49, }),

    Group::ArrayOfIndex({242, 139, 147, 52, 35, 53, 82, all_frequencies.isnull() ? Index(all_frequencies_default.pos()) : Group::Index(all_frequencies.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudbox_field_monoSetConst(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector value) {

  if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceVector since it is agenda input to cloudbox_field_monoSetConst");

  }


  return MRecord(362,

    Group::ArrayOfIndex({50, }),

    Group::ArrayOfIndex({242, 139, 147, 52, 35, 306, Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudbox_fieldSetConst(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector value) {

  if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceVector since it is agenda input to cloudbox_fieldSetConst");

  }


  return MRecord(363,

    Group::ArrayOfIndex({49, }),

    Group::ArrayOfIndex({242, 139, 147, 52, 35, 306, Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudbox_fieldSetConstPerFreq(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix value) {

  if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceMatrix since it is agenda input to cloudbox_fieldSetConstPerFreq");

  }


  return MRecord(364,

    Group::ArrayOfIndex({49, }),

    Group::ArrayOfIndex({242, 139, 147, 52, 35, 306, Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudbox_fieldUpdate1D(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(365,

    Group::ArrayOfIndex({50, }),

    Group::ArrayOfIndex({87, 52, 238, 344, 305, 378, 213, 223, 220, 221, 242, 381, 250, 338, 104, 105, 318, 90, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudbox_fieldUpdateSeq1D(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& normalize={},

               const Var::Numeric& norm_error_threshold={},

               const Var::Index& norm_debug={}) {

  if (not normalize.isnull() and normalize.islast()) {

    throw std::runtime_error("normalize needs to be a defined WorkspaceIndex (or left default) since it is agenda input to cloudbox_fieldUpdateSeq1D");

  } if (not norm_error_threshold.isnull() and norm_error_threshold.islast()) {

    throw std::runtime_error("norm_error_threshold needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to cloudbox_fieldUpdateSeq1D");

  } if (not norm_debug.isnull() and norm_debug.islast()) {

    throw std::runtime_error("norm_debug needs to be a defined WorkspaceIndex (or left default) since it is agenda input to cloudbox_fieldUpdateSeq1D");

  }


  static const auto normalize_default = Var::IndexCreate(ws, 1,

    "cloudbox_fieldUpdateSeq1D_normalize_autodefault",

    "auto generated variable with default from method definition");

  static const auto norm_error_threshold_default = Var::NumericCreate(ws, 1.0,

    "cloudbox_fieldUpdateSeq1D_norm_error_threshold_autodefault",

    "auto generated variable with default from method definition");

  static const auto norm_debug_default = Var::IndexCreate(ws, 0,

    "cloudbox_fieldUpdateSeq1D_norm_debug_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(366,

    Group::ArrayOfIndex({50, 87, }),

    Group::ArrayOfIndex({52, 238, 344, 305, 378, 0, 213, 223, 220, 221, 242, 381, 250, 338, 104, 105, 318, 90, normalize.isnull() ? Index(normalize_default.pos()) : Group::Index(normalize.pos()), norm_error_threshold.isnull() ? Index(norm_error_threshold_default.pos()) : Group::Index(norm_error_threshold.pos()), norm_debug.isnull() ? Index(norm_debug_default.pos()) : Group::Index(norm_debug.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudbox_fieldUpdateSeq1DPP(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(367,

    Group::ArrayOfIndex({50, 380, }),

    Group::ArrayOfIndex({87, 52, 238, 344, 305, 378, 213, 242, 381, 338, 104, 105, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudbox_fieldUpdateSeq3D(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(368,

    Group::ArrayOfIndex({50, }),

    Group::ArrayOfIndex({87, 52, 238, 344, 305, 378, 0, 213, 223, 220, 221, 242, 139, 147, 381, 250, 338, 104, 105, 90, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord cloudbox_field_monoOptimizeReverse(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(369,

    Group::ArrayOfIndex({50, }),

    Group::ArrayOfIndex({243, 242, 52, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Compare(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric var1,

               const Var::Numeric var2,

               const Var::Numeric& maxabsdiff={},

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceNumeric since it is agenda input to Compare");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceNumeric since it is agenda input to Compare");

  } if (not maxabsdiff.isnull() and maxabsdiff.islast()) {

    throw std::runtime_error("maxabsdiff needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to Compare");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to Compare");

  }


  static const auto maxabsdiff_default = Var::NumericCreate(ws, {},

    "Compare_maxabsdiff_autodefault",

    "auto generated variable with default from method definition");

  static const auto error_message_default = Var::StringCreate(ws, "",

    "Compare_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(370,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), maxabsdiff.isnull() ? Index(maxabsdiff_default.pos()) : Group::Index(maxabsdiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Compare(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector var1,

               const Var::Vector var2,

               const Var::Numeric& maxabsdiff={},

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceVector since it is agenda input to Compare");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceVector since it is agenda input to Compare");

  } if (not maxabsdiff.isnull() and maxabsdiff.islast()) {

    throw std::runtime_error("maxabsdiff needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to Compare");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to Compare");

  }


  static const auto maxabsdiff_default = Var::NumericCreate(ws, {},

    "Compare_maxabsdiff_autodefault",

    "auto generated variable with default from method definition");

  static const auto error_message_default = Var::StringCreate(ws, "",

    "Compare_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(371,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), maxabsdiff.isnull() ? Index(maxabsdiff_default.pos()) : Group::Index(maxabsdiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Compare(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix var1,

               const Var::Matrix var2,

               const Var::Numeric& maxabsdiff={},

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceMatrix since it is agenda input to Compare");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceMatrix since it is agenda input to Compare");

  } if (not maxabsdiff.isnull() and maxabsdiff.islast()) {

    throw std::runtime_error("maxabsdiff needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to Compare");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to Compare");

  }


  static const auto maxabsdiff_default = Var::NumericCreate(ws, {},

    "Compare_maxabsdiff_autodefault",

    "auto generated variable with default from method definition");

  static const auto error_message_default = Var::StringCreate(ws, "",

    "Compare_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(372,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), maxabsdiff.isnull() ? Index(maxabsdiff_default.pos()) : Group::Index(maxabsdiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Compare(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor3 var1,

               const Var::Tensor3 var2,

               const Var::Numeric& maxabsdiff={},

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceTensor3 since it is agenda input to Compare");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceTensor3 since it is agenda input to Compare");

  } if (not maxabsdiff.isnull() and maxabsdiff.islast()) {

    throw std::runtime_error("maxabsdiff needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to Compare");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to Compare");

  }


  static const auto maxabsdiff_default = Var::NumericCreate(ws, {},

    "Compare_maxabsdiff_autodefault",

    "auto generated variable with default from method definition");

  static const auto error_message_default = Var::StringCreate(ws, "",

    "Compare_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(373,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), maxabsdiff.isnull() ? Index(maxabsdiff_default.pos()) : Group::Index(maxabsdiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Compare(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 var1,

               const Var::Tensor4 var2,

               const Var::Numeric& maxabsdiff={},

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceTensor4 since it is agenda input to Compare");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceTensor4 since it is agenda input to Compare");

  } if (not maxabsdiff.isnull() and maxabsdiff.islast()) {

    throw std::runtime_error("maxabsdiff needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to Compare");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to Compare");

  }


  static const auto maxabsdiff_default = Var::NumericCreate(ws, {},

    "Compare_maxabsdiff_autodefault",

    "auto generated variable with default from method definition");

  static const auto error_message_default = Var::StringCreate(ws, "",

    "Compare_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(374,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), maxabsdiff.isnull() ? Index(maxabsdiff_default.pos()) : Group::Index(maxabsdiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Compare(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor5 var1,

               const Var::Tensor5 var2,

               const Var::Numeric& maxabsdiff={},

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceTensor5 since it is agenda input to Compare");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceTensor5 since it is agenda input to Compare");

  } if (not maxabsdiff.isnull() and maxabsdiff.islast()) {

    throw std::runtime_error("maxabsdiff needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to Compare");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to Compare");

  }


  static const auto maxabsdiff_default = Var::NumericCreate(ws, {},

    "Compare_maxabsdiff_autodefault",

    "auto generated variable with default from method definition");

  static const auto error_message_default = Var::StringCreate(ws, "",

    "Compare_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(375,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), maxabsdiff.isnull() ? Index(maxabsdiff_default.pos()) : Group::Index(maxabsdiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Compare(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 var1,

               const Var::Tensor7 var2,

               const Var::Numeric& maxabsdiff={},

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceTensor7 since it is agenda input to Compare");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceTensor7 since it is agenda input to Compare");

  } if (not maxabsdiff.isnull() and maxabsdiff.islast()) {

    throw std::runtime_error("maxabsdiff needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to Compare");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to Compare");

  }


  static const auto maxabsdiff_default = Var::NumericCreate(ws, {},

    "Compare_maxabsdiff_autodefault",

    "auto generated variable with default from method definition");

  static const auto error_message_default = Var::StringCreate(ws, "",

    "Compare_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(376,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), maxabsdiff.isnull() ? Index(maxabsdiff_default.pos()) : Group::Index(maxabsdiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Compare(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfVector var1,

               const Var::ArrayOfVector var2,

               const Var::Numeric& maxabsdiff={},

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfVector since it is agenda input to Compare");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfVector since it is agenda input to Compare");

  } if (not maxabsdiff.isnull() and maxabsdiff.islast()) {

    throw std::runtime_error("maxabsdiff needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to Compare");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to Compare");

  }


  static const auto maxabsdiff_default = Var::NumericCreate(ws, {},

    "Compare_maxabsdiff_autodefault",

    "auto generated variable with default from method definition");

  static const auto error_message_default = Var::StringCreate(ws, "",

    "Compare_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(377,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), maxabsdiff.isnull() ? Index(maxabsdiff_default.pos()) : Group::Index(maxabsdiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Compare(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfMatrix var1,

               const Var::ArrayOfMatrix var2,

               const Var::Numeric& maxabsdiff={},

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to Compare");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to Compare");

  } if (not maxabsdiff.isnull() and maxabsdiff.islast()) {

    throw std::runtime_error("maxabsdiff needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to Compare");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to Compare");

  }


  static const auto maxabsdiff_default = Var::NumericCreate(ws, {},

    "Compare_maxabsdiff_autodefault",

    "auto generated variable with default from method definition");

  static const auto error_message_default = Var::StringCreate(ws, "",

    "Compare_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(378,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), maxabsdiff.isnull() ? Index(maxabsdiff_default.pos()) : Group::Index(maxabsdiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Compare(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor7 var1,

               const Var::ArrayOfTensor7 var2,

               const Var::Numeric& maxabsdiff={},

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfTensor7 since it is agenda input to Compare");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfTensor7 since it is agenda input to Compare");

  } if (not maxabsdiff.isnull() and maxabsdiff.islast()) {

    throw std::runtime_error("maxabsdiff needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to Compare");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to Compare");

  }


  static const auto maxabsdiff_default = Var::NumericCreate(ws, {},

    "Compare_maxabsdiff_autodefault",

    "auto generated variable with default from method definition");

  static const auto error_message_default = Var::StringCreate(ws, "",

    "Compare_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(379,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), maxabsdiff.isnull() ? Index(maxabsdiff_default.pos()) : Group::Index(maxabsdiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Compare(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField3 var1,

               const Var::GriddedField3 var2,

               const Var::Numeric& maxabsdiff={},

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceGriddedField3 since it is agenda input to Compare");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceGriddedField3 since it is agenda input to Compare");

  } if (not maxabsdiff.isnull() and maxabsdiff.islast()) {

    throw std::runtime_error("maxabsdiff needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to Compare");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to Compare");

  }


  static const auto maxabsdiff_default = Var::NumericCreate(ws, {},

    "Compare_maxabsdiff_autodefault",

    "auto generated variable with default from method definition");

  static const auto error_message_default = Var::StringCreate(ws, "",

    "Compare_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(380,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), maxabsdiff.isnull() ? Index(maxabsdiff_default.pos()) : Group::Index(maxabsdiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Compare(

    [[maybe_unused]] Workspace& ws,

               const Var::Sparse var1,

               const Var::Sparse var2,

               const Var::Numeric& maxabsdiff={},

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceSparse since it is agenda input to Compare");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceSparse since it is agenda input to Compare");

  } if (not maxabsdiff.isnull() and maxabsdiff.islast()) {

    throw std::runtime_error("maxabsdiff needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to Compare");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to Compare");

  }


  static const auto maxabsdiff_default = Var::NumericCreate(ws, {},

    "Compare_maxabsdiff_autodefault",

    "auto generated variable with default from method definition");

  static const auto error_message_default = Var::StringCreate(ws, "",

    "Compare_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(381,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), maxabsdiff.isnull() ? Index(maxabsdiff_default.pos()) : Group::Index(maxabsdiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Compare(

    [[maybe_unused]] Workspace& ws,

               const Var::SingleScatteringData var1,

               const Var::SingleScatteringData var2,

               const Var::Numeric& maxabsdiff={},

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceSingleScatteringData since it is agenda input to Compare");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceSingleScatteringData since it is agenda input to Compare");

  } if (not maxabsdiff.isnull() and maxabsdiff.islast()) {

    throw std::runtime_error("maxabsdiff needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to Compare");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to Compare");

  }


  static const auto maxabsdiff_default = Var::NumericCreate(ws, {},

    "Compare_maxabsdiff_autodefault",

    "auto generated variable with default from method definition");

  static const auto error_message_default = Var::StringCreate(ws, "",

    "Compare_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(382,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), maxabsdiff.isnull() ? Index(maxabsdiff_default.pos()) : Group::Index(maxabsdiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric var1,

               const Var::Numeric var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(383,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector var1,

               const Var::Vector var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceVector since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceVector since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(384,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix var1,

               const Var::Matrix var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceMatrix since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceMatrix since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(385,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor3 var1,

               const Var::Tensor3 var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceTensor3 since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceTensor3 since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(386,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 var1,

               const Var::Tensor4 var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceTensor4 since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceTensor4 since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(387,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor5 var1,

               const Var::Tensor5 var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceTensor5 since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceTensor5 since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(388,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor6 var1,

               const Var::Tensor6 var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceTensor6 since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceTensor6 since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(389,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 var1,

               const Var::Tensor7 var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceTensor7 since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceTensor7 since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(390,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfVector var1,

               const Var::ArrayOfVector var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfVector since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfVector since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(391,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfMatrix var1,

               const Var::ArrayOfMatrix var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(392,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor3 var1,

               const Var::ArrayOfTensor3 var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfTensor3 since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfTensor3 since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(393,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor4 var1,

               const Var::ArrayOfTensor4 var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfTensor4 since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfTensor4 since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(394,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor6 var1,

               const Var::ArrayOfTensor6 var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfTensor6 since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfTensor6 since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(395,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor7 var1,

               const Var::ArrayOfTensor7 var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfTensor7 since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfTensor7 since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(396,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfVector var1,

               const Var::ArrayOfArrayOfVector var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfArrayOfVector since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfArrayOfVector since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(397,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfMatrix var1,

               const Var::ArrayOfArrayOfMatrix var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(398,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor3 var1,

               const Var::ArrayOfArrayOfTensor3 var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(399,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor6 var1,

               const Var::ArrayOfArrayOfTensor6 var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(400,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPropagationMatrix var1,

               const Var::ArrayOfPropagationMatrix var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfPropagationMatrix since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfPropagationMatrix since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(401,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfPropagationMatrix var1,

               const Var::ArrayOfArrayOfPropagationMatrix var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(402,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfStokesVector var1,

               const Var::ArrayOfStokesVector var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfStokesVector since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfStokesVector since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(403,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfStokesVector var1,

               const Var::ArrayOfArrayOfStokesVector var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(404,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord CompareRelative(

    [[maybe_unused]] Workspace& ws,

               const Var::EnergyLevelMap var1,

               const Var::EnergyLevelMap var2,

               const Var::Numeric maxabsreldiff,

               const Var::String& error_message={}) {

  if (var1.islast()) {

    throw std::runtime_error("var1 needs to be a defined WorkspaceEnergyLevelMap since it is agenda input to CompareRelative");

  } if (var2.islast()) {

    throw std::runtime_error("var2 needs to be a defined WorkspaceEnergyLevelMap since it is agenda input to CompareRelative");

  } if (maxabsreldiff.islast()) {

    throw std::runtime_error("maxabsreldiff needs to be a defined WorkspaceNumeric since it is agenda input to CompareRelative");

  } if (not error_message.isnull() and error_message.islast()) {

    throw std::runtime_error("error_message needs to be a defined WorkspaceString (or left default) since it is agenda input to CompareRelative");

  }


  static const auto error_message_default = Var::StringCreate(ws, "",

    "CompareRelative_error_message_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(405,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(var1.pos()), Group::Index(var2.pos()), Group::Index(maxabsreldiff.pos()), error_message.isnull() ? Index(error_message_default.pos()) : Group::Index(error_message.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord complex_refr_indexConstant(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric refr_index_real,

               const Var::Numeric refr_index_imag) {

  if (refr_index_real.islast()) {

    throw std::runtime_error("refr_index_real needs to be a defined WorkspaceNumeric since it is agenda input to complex_refr_indexConstant");

  } if (refr_index_imag.islast()) {

    throw std::runtime_error("refr_index_imag needs to be a defined WorkspaceNumeric since it is agenda input to complex_refr_indexConstant");

  }


  return MRecord(406,

    Group::ArrayOfIndex({54, }),

    Group::ArrayOfIndex({Group::Index(refr_index_real.pos()), Group::Index(refr_index_imag.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord complex_refr_indexIceMatzler06(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector data_f_grid,

               const Var::Vector data_T_grid) {

  if (data_f_grid.islast()) {

    throw std::runtime_error("data_f_grid needs to be a defined WorkspaceVector since it is agenda input to complex_refr_indexIceMatzler06");

  } if (data_T_grid.islast()) {

    throw std::runtime_error("data_T_grid needs to be a defined WorkspaceVector since it is agenda input to complex_refr_indexIceMatzler06");

  }


  return MRecord(407,

    Group::ArrayOfIndex({54, }),

    Group::ArrayOfIndex({Group::Index(data_f_grid.pos()), Group::Index(data_T_grid.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord complex_refr_indexIceWarren84(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector data_f_grid,

               const Var::Vector data_T_grid) {

  if (data_f_grid.islast()) {

    throw std::runtime_error("data_f_grid needs to be a defined WorkspaceVector since it is agenda input to complex_refr_indexIceWarren84");

  } if (data_T_grid.islast()) {

    throw std::runtime_error("data_T_grid needs to be a defined WorkspaceVector since it is agenda input to complex_refr_indexIceWarren84");

  }


  return MRecord(408,

    Group::ArrayOfIndex({54, }),

    Group::ArrayOfIndex({Group::Index(data_f_grid.pos()), Group::Index(data_T_grid.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord complex_refr_indexWaterLiebe93(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector data_f_grid,

               const Var::Vector data_T_grid) {

  if (data_f_grid.islast()) {

    throw std::runtime_error("data_f_grid needs to be a defined WorkspaceVector since it is agenda input to complex_refr_indexWaterLiebe93");

  } if (data_T_grid.islast()) {

    throw std::runtime_error("data_T_grid needs to be a defined WorkspaceVector since it is agenda input to complex_refr_indexWaterLiebe93");

  }


  return MRecord(409,

    Group::ArrayOfIndex({54, }),

    Group::ArrayOfIndex({Group::Index(data_f_grid.pos()), Group::Index(data_T_grid.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::AbsorptionLines out,

               const Var::AbsorptionLines in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceAbsorptionLines since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAbsorptionLines since it is agenda input to Copy");

  }


  return MRecord(410,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Agenda out,

               const Var::Agenda in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceAgenda since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAgenda since it is agenda input to Copy");

  }


  return MRecord(411,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfAbsorptionLines out,

               const Var::ArrayOfAbsorptionLines in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAbsorptionLines since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAbsorptionLines since it is agenda input to Copy");

  }


  return MRecord(412,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfAbsorptionLines out,

               const Var::ArrayOfArrayOfAbsorptionLines in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is agenda input to Copy");

  }


  return MRecord(413,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfAgenda out,

               const Var::ArrayOfAgenda in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAgenda since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAgenda since it is agenda input to Copy");

  }


  return MRecord(414,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField1 out,

               const Var::ArrayOfArrayOfGriddedField1 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is agenda input to Copy");

  }


  return MRecord(415,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField2 out,

               const Var::ArrayOfArrayOfGriddedField2 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is agenda input to Copy");

  }


  return MRecord(416,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField3 out,

               const Var::ArrayOfArrayOfGriddedField3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is agenda input to Copy");

  }


  return MRecord(417,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfIndex out,

               const Var::ArrayOfArrayOfIndex in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfIndex since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfIndex since it is agenda input to Copy");

  }


  return MRecord(418,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfMatrix out,

               const Var::ArrayOfArrayOfMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is agenda input to Copy");

  }


  return MRecord(419,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfPpath out,

               const Var::ArrayOfPpath in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPpath since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPpath since it is agenda input to Copy");

  }


  return MRecord(420,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfPropagationMatrix out,

               const Var::ArrayOfArrayOfPropagationMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is agenda input to Copy");

  }


  return MRecord(421,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfRadiationVector out,

               const Var::ArrayOfArrayOfRadiationVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is agenda input to Copy");

  }


  return MRecord(422,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfScatteringMetaData out,

               const Var::ArrayOfArrayOfScatteringMetaData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is agenda input to Copy");

  }


  return MRecord(423,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfSingleScatteringData out,

               const Var::ArrayOfArrayOfSingleScatteringData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is agenda input to Copy");

  }


  return MRecord(424,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfSpeciesTag out,

               const Var::ArrayOfArrayOfSpeciesTag in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is agenda input to Copy");

  }


  return MRecord(425,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfStokesVector out,

               const Var::ArrayOfArrayOfStokesVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is agenda input to Copy");

  }


  return MRecord(426,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfString out,

               const Var::ArrayOfArrayOfString in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfString since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfString since it is agenda input to Copy");

  }


  return MRecord(427,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTensor3 out,

               const Var::ArrayOfArrayOfTensor3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is agenda input to Copy");

  }


  return MRecord(428,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTensor6 out,

               const Var::ArrayOfArrayOfTensor6 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is agenda input to Copy");

  }


  return MRecord(429,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTime out,

               const Var::ArrayOfArrayOfTime in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTime since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTime since it is agenda input to Copy");

  }


  return MRecord(430,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTransmissionMatrix out,

               const Var::ArrayOfArrayOfTransmissionMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is agenda input to Copy");

  }


  return MRecord(431,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfVector out,

               const Var::ArrayOfArrayOfVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfVector since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfVector since it is agenda input to Copy");

  }


  return MRecord(432,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfCIARecord out,

               const Var::ArrayOfCIARecord in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfCIARecord since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfCIARecord since it is agenda input to Copy");

  }


  return MRecord(433,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField1 out,

               const Var::ArrayOfGriddedField1 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField1 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField1 since it is agenda input to Copy");

  }


  return MRecord(434,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField2 out,

               const Var::ArrayOfGriddedField2 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField2 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField2 since it is agenda input to Copy");

  }


  return MRecord(435,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField3 out,

               const Var::ArrayOfGriddedField3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to Copy");

  }


  return MRecord(436,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField4 out,

               const Var::ArrayOfGriddedField4 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField4 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField4 since it is agenda input to Copy");

  }


  return MRecord(437,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfIndex out,

               const Var::ArrayOfIndex in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Copy");

  }


  return MRecord(438,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfMatrix out,

               const Var::ArrayOfMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfMatrix since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to Copy");

  }


  return MRecord(439,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfPropagationMatrix out,

               const Var::ArrayOfPropagationMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPropagationMatrix since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPropagationMatrix since it is agenda input to Copy");

  }


  return MRecord(440,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfQuantumIdentifier out,

               const Var::ArrayOfQuantumIdentifier in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to Copy");

  }


  return MRecord(441,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfRadiationVector out,

               const Var::ArrayOfRadiationVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRadiationVector since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRadiationVector since it is agenda input to Copy");

  }


  return MRecord(442,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfRetrievalQuantity out,

               const Var::ArrayOfRetrievalQuantity in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is agenda input to Copy");

  }


  return MRecord(443,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfScatteringMetaData out,

               const Var::ArrayOfScatteringMetaData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfScatteringMetaData since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfScatteringMetaData since it is agenda input to Copy");

  }


  return MRecord(444,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSingleScatteringData out,

               const Var::ArrayOfSingleScatteringData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSingleScatteringData since it is agenda input to Copy");

  }


  return MRecord(445,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSparse out,

               const Var::ArrayOfSparse in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSparse since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSparse since it is agenda input to Copy");

  }


  return MRecord(446,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfStokesVector out,

               const Var::ArrayOfStokesVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfStokesVector since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfStokesVector since it is agenda input to Copy");

  }


  return MRecord(447,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfString out,

               const Var::ArrayOfString in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfString since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfString since it is agenda input to Copy");

  }


  return MRecord(448,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTelsemAtlas out,

               const Var::ArrayOfTelsemAtlas in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTelsemAtlas since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTelsemAtlas since it is agenda input to Copy");

  }


  return MRecord(449,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor3 out,

               const Var::ArrayOfTensor3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor3 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor3 since it is agenda input to Copy");

  }


  return MRecord(450,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor4 out,

               const Var::ArrayOfTensor4 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor4 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor4 since it is agenda input to Copy");

  }


  return MRecord(451,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor5 out,

               const Var::ArrayOfTensor5 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor5 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor5 since it is agenda input to Copy");

  }


  return MRecord(452,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor6 out,

               const Var::ArrayOfTensor6 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor6 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor6 since it is agenda input to Copy");

  }


  return MRecord(453,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor7 out,

               const Var::ArrayOfTensor7 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor7 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor7 since it is agenda input to Copy");

  }


  return MRecord(454,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTime out,

               const Var::ArrayOfTime in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTime since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTime since it is agenda input to Copy");

  }


  return MRecord(455,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTransmissionMatrix out,

               const Var::ArrayOfTransmissionMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is agenda input to Copy");

  }


  return MRecord(456,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfVector out,

               const Var::ArrayOfVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfVector since it is agenda input to Copy");

  }


  return MRecord(457,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfXsecRecord out,

               const Var::ArrayOfXsecRecord in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfXsecRecord since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfXsecRecord since it is agenda input to Copy");

  }


  return MRecord(458,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::CIARecord out,

               const Var::CIARecord in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceCIARecord since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCIARecord since it is agenda input to Copy");

  }


  return MRecord(459,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::CovarianceMatrix out,

               const Var::CovarianceMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceCovarianceMatrix since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCovarianceMatrix since it is agenda input to Copy");

  }


  return MRecord(460,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::EnergyLevelMap out,

               const Var::EnergyLevelMap in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceEnergyLevelMap since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceEnergyLevelMap since it is agenda input to Copy");

  }


  return MRecord(461,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::GasAbsLookup out,

               const Var::GasAbsLookup in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGasAbsLookup since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGasAbsLookup since it is agenda input to Copy");

  }


  return MRecord(462,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::GridPos out,

               const Var::GridPos in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGridPos since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGridPos since it is agenda input to Copy");

  }


  return MRecord(463,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField1 out,

               const Var::GriddedField1 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField1 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField1 since it is agenda input to Copy");

  }


  return MRecord(464,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField2 out,

               const Var::GriddedField2 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField2 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField2 since it is agenda input to Copy");

  }


  return MRecord(465,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField3 out,

               const Var::GriddedField3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField3 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField3 since it is agenda input to Copy");

  }


  return MRecord(466,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField4 out,

               const Var::GriddedField4 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField4 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField4 since it is agenda input to Copy");

  }


  return MRecord(467,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField5 out,

               const Var::GriddedField5 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField5 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField5 since it is agenda input to Copy");

  }


  return MRecord(468,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField6 out,

               const Var::GriddedField6 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField6 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField6 since it is agenda input to Copy");

  }


  return MRecord(469,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::HitranRelaxationMatrixData out,

               const Var::HitranRelaxationMatrixData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceHitranRelaxationMatrixData since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceHitranRelaxationMatrixData since it is agenda input to Copy");

  }


  return MRecord(470,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Index out,

               const Var::Index in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceIndex since it is agenda input to Copy");

  }


  return MRecord(471,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::MCAntenna out,

               const Var::MCAntenna in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMCAntenna since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMCAntenna since it is agenda input to Copy");

  }


  return MRecord(472,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Matrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is agenda input to Copy");

  }


  return MRecord(473,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric out,

               const Var::Numeric in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceNumeric since it is agenda input to Copy");

  }


  return MRecord(474,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Ppath out,

               const Var::Ppath in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspacePpath since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePpath since it is agenda input to Copy");

  }


  return MRecord(475,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::PropagationMatrix out,

               const Var::PropagationMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspacePropagationMatrix since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePropagationMatrix since it is agenda input to Copy");

  }


  return MRecord(476,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::QuantumIdentifier out,

               const Var::QuantumIdentifier in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceQuantumIdentifier since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to Copy");

  }


  return MRecord(477,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::RadiationVector out,

               const Var::RadiationVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRadiationVector since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRadiationVector since it is agenda input to Copy");

  }


  return MRecord(478,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Rational out,

               const Var::Rational in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRational since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRational since it is agenda input to Copy");

  }


  return MRecord(479,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::ScatteringMetaData out,

               const Var::ScatteringMetaData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceScatteringMetaData since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceScatteringMetaData since it is agenda input to Copy");

  }


  return MRecord(480,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::SingleScatteringData out,

               const Var::SingleScatteringData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSingleScatteringData since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSingleScatteringData since it is agenda input to Copy");

  }


  return MRecord(481,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Sparse out,

               const Var::Sparse in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSparse since it is agenda input to Copy");

  }


  return MRecord(482,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::SpeciesAuxData out,

               const Var::SpeciesAuxData in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSpeciesAuxData since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSpeciesAuxData since it is agenda input to Copy");

  }


  return MRecord(483,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::StokesVector out,

               const Var::StokesVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceStokesVector since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceStokesVector since it is agenda input to Copy");

  }


  return MRecord(484,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::String out,

               const Var::String in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceString since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceString since it is agenda input to Copy");

  }


  return MRecord(485,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::TelsemAtlas out,

               const Var::TelsemAtlas in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTelsemAtlas since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTelsemAtlas since it is agenda input to Copy");

  }


  return MRecord(486,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 out,

               const Var::Tensor3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is agenda input to Copy");

  }


  return MRecord(487,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 out,

               const Var::Tensor4 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is agenda input to Copy");

  }


  return MRecord(488,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor5 out,

               const Var::Tensor5 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor5 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor5 since it is agenda input to Copy");

  }


  return MRecord(489,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor6 out,

               const Var::Tensor6 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor6 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor6 since it is agenda input to Copy");

  }


  return MRecord(490,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor7 out,

               const Var::Tensor7 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor7 since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor7 since it is agenda input to Copy");

  }


  return MRecord(491,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Timer out,

               const Var::Timer in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTimer since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTimer since it is agenda input to Copy");

  }


  return MRecord(492,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Time out,

               const Var::Time in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTime since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTime since it is agenda input to Copy");

  }


  return MRecord(493,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::TessemNN out,

               const Var::TessemNN in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTessemNN since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTessemNN since it is agenda input to Copy");

  }


  return MRecord(494,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::TransmissionMatrix out,

               const Var::TransmissionMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTransmissionMatrix since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTransmissionMatrix since it is agenda input to Copy");

  }


  return MRecord(495,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Vector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to Copy");

  }


  return MRecord(496,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Copy(

    [[maybe_unused]] Workspace& ws,

                     Var::Verbosity out,

               const Var::Verbosity in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVerbosity since it is output of Copy");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVerbosity since it is agenda input to Copy");

  }


  return MRecord(497,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat1D(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Vector grid_1,

               const Var::Vector sigma_1,

               const Var::Vector cls_1,

               const Var::String fname,

               const Var::Vector& grid_2={},

               const Var::Vector& sigma_2={},

               const Var::Vector& cls_2={},

               const Var::Numeric& co={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of covmat1D");

  } if (grid_1.islast()) {

    throw std::runtime_error("grid_1 needs to be a defined WorkspaceVector since it is agenda input to covmat1D");

  } if (not grid_2.isnull() and grid_2.islast()) {

    throw std::runtime_error("grid_2 needs to be a defined WorkspaceVector (or left default) since it is agenda input to covmat1D");

  } if (sigma_1.islast()) {

    throw std::runtime_error("sigma_1 needs to be a defined WorkspaceVector since it is agenda input to covmat1D");

  } if (not sigma_2.isnull() and sigma_2.islast()) {

    throw std::runtime_error("sigma_2 needs to be a defined WorkspaceVector (or left default) since it is agenda input to covmat1D");

  } if (cls_1.islast()) {

    throw std::runtime_error("cls_1 needs to be a defined WorkspaceVector since it is agenda input to covmat1D");

  } if (not cls_2.isnull() and cls_2.islast()) {

    throw std::runtime_error("cls_2 needs to be a defined WorkspaceVector (or left default) since it is agenda input to covmat1D");

  } if (not co.isnull() and co.islast()) {

    throw std::runtime_error("co needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to covmat1D");

  } if (fname.islast()) {

    throw std::runtime_error("fname needs to be a defined WorkspaceString since it is agenda input to covmat1D");

  }


  static const auto grid_2_default = Var::VectorCreate(ws, {},

    "covmat1D_grid_2_autodefault",

    "auto generated variable with default from method definition");

  static const auto sigma_2_default = Var::VectorCreate(ws, {},

    "covmat1D_sigma_2_autodefault",

    "auto generated variable with default from method definition");

  static const auto cls_2_default = Var::VectorCreate(ws, {},

    "covmat1D_cls_2_autodefault",

    "auto generated variable with default from method definition");

  static const auto co_default = Var::NumericCreate(ws, 0.0,

    "covmat1D_co_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(498,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(grid_1.pos()), grid_2.isnull() ? Index(grid_2_default.pos()) : Group::Index(grid_2.pos()), Group::Index(sigma_1.pos()), sigma_2.isnull() ? Index(sigma_2_default.pos()) : Group::Index(sigma_2.pos()), Group::Index(cls_1.pos()), cls_2.isnull() ? Index(cls_2_default.pos()) : Group::Index(cls_2.pos()), co.isnull() ? Index(co_default.pos()) : Group::Index(co.pos()), Group::Index(fname.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat1D(

    [[maybe_unused]] Workspace& ws,

                     Var::Sparse out,

               const Var::Vector grid_1,

               const Var::Vector sigma_1,

               const Var::Vector cls_1,

               const Var::String fname,

               const Var::Vector& grid_2={},

               const Var::Vector& sigma_2={},

               const Var::Vector& cls_2={},

               const Var::Numeric& co={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of covmat1D");

  } if (grid_1.islast()) {

    throw std::runtime_error("grid_1 needs to be a defined WorkspaceVector since it is agenda input to covmat1D");

  } if (not grid_2.isnull() and grid_2.islast()) {

    throw std::runtime_error("grid_2 needs to be a defined WorkspaceVector (or left default) since it is agenda input to covmat1D");

  } if (sigma_1.islast()) {

    throw std::runtime_error("sigma_1 needs to be a defined WorkspaceVector since it is agenda input to covmat1D");

  } if (not sigma_2.isnull() and sigma_2.islast()) {

    throw std::runtime_error("sigma_2 needs to be a defined WorkspaceVector (or left default) since it is agenda input to covmat1D");

  } if (cls_1.islast()) {

    throw std::runtime_error("cls_1 needs to be a defined WorkspaceVector since it is agenda input to covmat1D");

  } if (not cls_2.isnull() and cls_2.islast()) {

    throw std::runtime_error("cls_2 needs to be a defined WorkspaceVector (or left default) since it is agenda input to covmat1D");

  } if (not co.isnull() and co.islast()) {

    throw std::runtime_error("co needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to covmat1D");

  } if (fname.islast()) {

    throw std::runtime_error("fname needs to be a defined WorkspaceString since it is agenda input to covmat1D");

  }


  static const auto grid_2_default = Var::VectorCreate(ws, {},

    "covmat1D_grid_2_autodefault",

    "auto generated variable with default from method definition");

  static const auto sigma_2_default = Var::VectorCreate(ws, {},

    "covmat1D_sigma_2_autodefault",

    "auto generated variable with default from method definition");

  static const auto cls_2_default = Var::VectorCreate(ws, {},

    "covmat1D_cls_2_autodefault",

    "auto generated variable with default from method definition");

  static const auto co_default = Var::NumericCreate(ws, 0.0,

    "covmat1D_co_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(499,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(grid_1.pos()), grid_2.isnull() ? Index(grid_2_default.pos()) : Group::Index(grid_2.pos()), Group::Index(sigma_1.pos()), sigma_2.isnull() ? Index(sigma_2_default.pos()) : Group::Index(sigma_2.pos()), Group::Index(cls_1.pos()), cls_2.isnull() ? Index(cls_2_default.pos()) : Group::Index(cls_2.pos()), co.isnull() ? Index(co_default.pos()) : Group::Index(co.pos()), Group::Index(fname.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat1DMarkov(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

                     Var::Matrix out_inverse,

               const Var::Vector grid,

               const Var::Vector sigma,

               const Var::Numeric lc,

               const Var::Numeric& co={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of covmat1DMarkov");

  } if (out_inverse.islast()) {

    throw std::runtime_error("out_inverse needs to be a defined WorkspaceMatrix since it is output of covmat1DMarkov");

  } if (grid.islast()) {

    throw std::runtime_error("grid needs to be a defined WorkspaceVector since it is agenda input to covmat1DMarkov");

  } if (sigma.islast()) {

    throw std::runtime_error("sigma needs to be a defined WorkspaceVector since it is agenda input to covmat1DMarkov");

  } if (lc.islast()) {

    throw std::runtime_error("lc needs to be a defined WorkspaceNumeric since it is agenda input to covmat1DMarkov");

  } if (not co.isnull() and co.islast()) {

    throw std::runtime_error("co needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to covmat1DMarkov");

  }


  static const auto co_default = Var::NumericCreate(ws, 0.0,

    "covmat1DMarkov_co_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(500,

    Group::ArrayOfIndex({Group::Index(out.pos()), Group::Index(out_inverse.pos()), }),

    Group::ArrayOfIndex({Group::Index(grid.pos()), Group::Index(sigma.pos()), Group::Index(lc.pos()), co.isnull() ? Index(co_default.pos()) : Group::Index(co.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat1DMarkov(

    [[maybe_unused]] Workspace& ws,

                     Var::Sparse out,

                     Var::Sparse out_inverse,

               const Var::Vector grid,

               const Var::Vector sigma,

               const Var::Numeric lc,

               const Var::Numeric& co={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of covmat1DMarkov");

  } if (out_inverse.islast()) {

    throw std::runtime_error("out_inverse needs to be a defined WorkspaceSparse since it is output of covmat1DMarkov");

  } if (grid.islast()) {

    throw std::runtime_error("grid needs to be a defined WorkspaceVector since it is agenda input to covmat1DMarkov");

  } if (sigma.islast()) {

    throw std::runtime_error("sigma needs to be a defined WorkspaceVector since it is agenda input to covmat1DMarkov");

  } if (lc.islast()) {

    throw std::runtime_error("lc needs to be a defined WorkspaceNumeric since it is agenda input to covmat1DMarkov");

  } if (not co.isnull() and co.islast()) {

    throw std::runtime_error("co needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to covmat1DMarkov");

  }


  static const auto co_default = Var::NumericCreate(ws, 0.0,

    "covmat1DMarkov_co_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(501,

    Group::ArrayOfIndex({Group::Index(out.pos()), Group::Index(out_inverse.pos()), }),

    Group::ArrayOfIndex({Group::Index(grid.pos()), Group::Index(sigma.pos()), Group::Index(lc.pos()), co.isnull() ? Index(co_default.pos()) : Group::Index(co.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmatDiagonal(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

                     Var::Matrix out_inverse,

               const Var::Vector vars) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of covmatDiagonal");

  } if (out_inverse.islast()) {

    throw std::runtime_error("out_inverse needs to be a defined WorkspaceMatrix since it is output of covmatDiagonal");

  } if (vars.islast()) {

    throw std::runtime_error("vars needs to be a defined WorkspaceVector since it is agenda input to covmatDiagonal");

  }


  return MRecord(502,

    Group::ArrayOfIndex({Group::Index(out.pos()), Group::Index(out_inverse.pos()), }),

    Group::ArrayOfIndex({Group::Index(vars.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmatDiagonal(

    [[maybe_unused]] Workspace& ws,

                     Var::Sparse out,

                     Var::Sparse out_inverse,

               const Var::Vector vars) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of covmatDiagonal");

  } if (out_inverse.islast()) {

    throw std::runtime_error("out_inverse needs to be a defined WorkspaceSparse since it is output of covmatDiagonal");

  } if (vars.islast()) {

    throw std::runtime_error("vars needs to be a defined WorkspaceVector since it is agenda input to covmatDiagonal");

  }


  return MRecord(503,

    Group::ArrayOfIndex({Group::Index(out.pos()), Group::Index(out_inverse.pos()), }),

    Group::ArrayOfIndex({Group::Index(vars.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_seAddBlock(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix block,

               const Var::Index& i={},

               const Var::Index& j={}) {

  if (block.islast()) {

    throw std::runtime_error("block needs to be a defined WorkspaceMatrix since it is agenda input to covmat_seAddBlock");

  } if (not i.isnull() and i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_seAddBlock");

  } if (not j.isnull() and j.islast()) {

    throw std::runtime_error("j needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_seAddBlock");

  }


  static const auto i_default = Var::IndexCreate(ws, -1,

    "covmat_seAddBlock_i_autodefault",

    "auto generated variable with default from method definition");

  static const auto j_default = Var::IndexCreate(ws, -1,

    "covmat_seAddBlock_j_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(504,

    Group::ArrayOfIndex({58, }),

    Group::ArrayOfIndex({Group::Index(block.pos()), i.isnull() ? Index(i_default.pos()) : Group::Index(i.pos()), j.isnull() ? Index(j_default.pos()) : Group::Index(j.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_seAddBlock(

    [[maybe_unused]] Workspace& ws,

               const Var::Sparse block,

               const Var::Index& i={},

               const Var::Index& j={}) {

  if (block.islast()) {

    throw std::runtime_error("block needs to be a defined WorkspaceSparse since it is agenda input to covmat_seAddBlock");

  } if (not i.isnull() and i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_seAddBlock");

  } if (not j.isnull() and j.islast()) {

    throw std::runtime_error("j needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_seAddBlock");

  }


  static const auto i_default = Var::IndexCreate(ws, -1,

    "covmat_seAddBlock_i_autodefault",

    "auto generated variable with default from method definition");

  static const auto j_default = Var::IndexCreate(ws, -1,

    "covmat_seAddBlock_j_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(505,

    Group::ArrayOfIndex({58, }),

    Group::ArrayOfIndex({Group::Index(block.pos()), i.isnull() ? Index(i_default.pos()) : Group::Index(i.pos()), j.isnull() ? Index(j_default.pos()) : Group::Index(j.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_seAddInverseBlock(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix block,

               const Var::Index& i={},

               const Var::Index& j={}) {

  if (block.islast()) {

    throw std::runtime_error("block needs to be a defined WorkspaceMatrix since it is agenda input to covmat_seAddInverseBlock");

  } if (not i.isnull() and i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_seAddInverseBlock");

  } if (not j.isnull() and j.islast()) {

    throw std::runtime_error("j needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_seAddInverseBlock");

  }


  static const auto i_default = Var::IndexCreate(ws, -1,

    "covmat_seAddInverseBlock_i_autodefault",

    "auto generated variable with default from method definition");

  static const auto j_default = Var::IndexCreate(ws, -1,

    "covmat_seAddInverseBlock_j_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(506,

    Group::ArrayOfIndex({58, }),

    Group::ArrayOfIndex({Group::Index(block.pos()), i.isnull() ? Index(i_default.pos()) : Group::Index(i.pos()), j.isnull() ? Index(j_default.pos()) : Group::Index(j.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_seAddInverseBlock(

    [[maybe_unused]] Workspace& ws,

               const Var::Sparse block,

               const Var::Index& i={},

               const Var::Index& j={}) {

  if (block.islast()) {

    throw std::runtime_error("block needs to be a defined WorkspaceSparse since it is agenda input to covmat_seAddInverseBlock");

  } if (not i.isnull() and i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_seAddInverseBlock");

  } if (not j.isnull() and j.islast()) {

    throw std::runtime_error("j needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_seAddInverseBlock");

  }


  static const auto i_default = Var::IndexCreate(ws, -1,

    "covmat_seAddInverseBlock_i_autodefault",

    "auto generated variable with default from method definition");

  static const auto j_default = Var::IndexCreate(ws, -1,

    "covmat_seAddInverseBlock_j_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(507,

    Group::ArrayOfIndex({58, }),

    Group::ArrayOfIndex({Group::Index(block.pos()), i.isnull() ? Index(i_default.pos()) : Group::Index(i.pos()), j.isnull() ? Index(j_default.pos()) : Group::Index(j.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_seSet(

    [[maybe_unused]] Workspace& ws,

               const Var::CovarianceMatrix covmat) {

  if (covmat.islast()) {

    throw std::runtime_error("covmat needs to be a defined WorkspaceCovarianceMatrix since it is agenda input to covmat_seSet");

  }


  return MRecord(508,

    Group::ArrayOfIndex({58, }),

    Group::ArrayOfIndex({Group::Index(covmat.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_seSet(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix covmat) {

  if (covmat.islast()) {

    throw std::runtime_error("covmat needs to be a defined WorkspaceMatrix since it is agenda input to covmat_seSet");

  }


  return MRecord(509,

    Group::ArrayOfIndex({58, }),

    Group::ArrayOfIndex({Group::Index(covmat.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_seSet(

    [[maybe_unused]] Workspace& ws,

               const Var::Sparse covmat) {

  if (covmat.islast()) {

    throw std::runtime_error("covmat needs to be a defined WorkspaceSparse since it is agenda input to covmat_seSet");

  }


  return MRecord(510,

    Group::ArrayOfIndex({58, }),

    Group::ArrayOfIndex({Group::Index(covmat.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_sxSet(

    [[maybe_unused]] Workspace& ws,

               const Var::CovarianceMatrix covmat) {

  if (covmat.islast()) {

    throw std::runtime_error("covmat needs to be a defined WorkspaceCovarianceMatrix since it is agenda input to covmat_sxSet");

  }


  return MRecord(511,

    Group::ArrayOfIndex({60, }),

    Group::ArrayOfIndex({Group::Index(covmat.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_sxSet(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix covmat) {

  if (covmat.islast()) {

    throw std::runtime_error("covmat needs to be a defined WorkspaceMatrix since it is agenda input to covmat_sxSet");

  }


  return MRecord(512,

    Group::ArrayOfIndex({60, }),

    Group::ArrayOfIndex({Group::Index(covmat.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_sxSet(

    [[maybe_unused]] Workspace& ws,

               const Var::Sparse covmat) {

  if (covmat.islast()) {

    throw std::runtime_error("covmat needs to be a defined WorkspaceSparse since it is agenda input to covmat_sxSet");

  }


  return MRecord(513,

    Group::ArrayOfIndex({60, }),

    Group::ArrayOfIndex({Group::Index(covmat.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_sxAddBlock(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix block,

               const Var::Index& i={},

               const Var::Index& j={}) {

  if (block.islast()) {

    throw std::runtime_error("block needs to be a defined WorkspaceMatrix since it is agenda input to covmat_sxAddBlock");

  } if (not i.isnull() and i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_sxAddBlock");

  } if (not j.isnull() and j.islast()) {

    throw std::runtime_error("j needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_sxAddBlock");

  }


  static const auto i_default = Var::IndexCreate(ws, -1,

    "covmat_sxAddBlock_i_autodefault",

    "auto generated variable with default from method definition");

  static const auto j_default = Var::IndexCreate(ws, -1,

    "covmat_sxAddBlock_j_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(514,

    Group::ArrayOfIndex({60, }),

    Group::ArrayOfIndex({137, Group::Index(block.pos()), i.isnull() ? Index(i_default.pos()) : Group::Index(i.pos()), j.isnull() ? Index(j_default.pos()) : Group::Index(j.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_sxAddBlock(

    [[maybe_unused]] Workspace& ws,

               const Var::Sparse block,

               const Var::Index& i={},

               const Var::Index& j={}) {

  if (block.islast()) {

    throw std::runtime_error("block needs to be a defined WorkspaceSparse since it is agenda input to covmat_sxAddBlock");

  } if (not i.isnull() and i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_sxAddBlock");

  } if (not j.isnull() and j.islast()) {

    throw std::runtime_error("j needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_sxAddBlock");

  }


  static const auto i_default = Var::IndexCreate(ws, -1,

    "covmat_sxAddBlock_i_autodefault",

    "auto generated variable with default from method definition");

  static const auto j_default = Var::IndexCreate(ws, -1,

    "covmat_sxAddBlock_j_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(515,

    Group::ArrayOfIndex({60, }),

    Group::ArrayOfIndex({137, Group::Index(block.pos()), i.isnull() ? Index(i_default.pos()) : Group::Index(i.pos()), j.isnull() ? Index(j_default.pos()) : Group::Index(j.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_sxAddInverseBlock(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix block,

               const Var::Index& i={},

               const Var::Index& j={}) {

  if (block.islast()) {

    throw std::runtime_error("block needs to be a defined WorkspaceMatrix since it is agenda input to covmat_sxAddInverseBlock");

  } if (not i.isnull() and i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_sxAddInverseBlock");

  } if (not j.isnull() and j.islast()) {

    throw std::runtime_error("j needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_sxAddInverseBlock");

  }


  static const auto i_default = Var::IndexCreate(ws, -1,

    "covmat_sxAddInverseBlock_i_autodefault",

    "auto generated variable with default from method definition");

  static const auto j_default = Var::IndexCreate(ws, -1,

    "covmat_sxAddInverseBlock_j_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(516,

    Group::ArrayOfIndex({60, }),

    Group::ArrayOfIndex({137, Group::Index(block.pos()), i.isnull() ? Index(i_default.pos()) : Group::Index(i.pos()), j.isnull() ? Index(j_default.pos()) : Group::Index(j.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_sxAddInverseBlock(

    [[maybe_unused]] Workspace& ws,

               const Var::Sparse block,

               const Var::Index& i={},

               const Var::Index& j={}) {

  if (block.islast()) {

    throw std::runtime_error("block needs to be a defined WorkspaceSparse since it is agenda input to covmat_sxAddInverseBlock");

  } if (not i.isnull() and i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_sxAddInverseBlock");

  } if (not j.isnull() and j.islast()) {

    throw std::runtime_error("j needs to be a defined WorkspaceIndex (or left default) since it is agenda input to covmat_sxAddInverseBlock");

  }


  static const auto i_default = Var::IndexCreate(ws, -1,

    "covmat_sxAddInverseBlock_i_autodefault",

    "auto generated variable with default from method definition");

  static const auto j_default = Var::IndexCreate(ws, -1,

    "covmat_sxAddInverseBlock_j_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(517,

    Group::ArrayOfIndex({60, }),

    Group::ArrayOfIndex({137, Group::Index(block.pos()), i.isnull() ? Index(i_default.pos()) : Group::Index(i.pos()), j.isnull() ? Index(j_default.pos()) : Group::Index(j.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_sxExtractSqrtDiagonal(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector x_norm) {

  if (x_norm.islast()) {

    throw std::runtime_error("x_norm needs to be a defined WorkspaceVector since it is output of covmat_sxExtractSqrtDiagonal");

  }


  return MRecord(518,

    Group::ArrayOfIndex({Group::Index(x_norm.pos()), }),

    Group::ArrayOfIndex({60, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::AbsorptionLines v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceAbsorptionLines since it is agenda input to Delete");

  }


  return MRecord(519,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Agenda v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceAgenda since it is agenda input to Delete");

  }


  return MRecord(520,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAbsorptionLines v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfAbsorptionLines since it is agenda input to Delete");

  }


  return MRecord(521,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfAbsorptionLines v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is agenda input to Delete");

  }


  return MRecord(522,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAgenda v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfAgenda since it is agenda input to Delete");

  }


  return MRecord(523,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField1 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is agenda input to Delete");

  }


  return MRecord(524,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField2 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is agenda input to Delete");

  }


  return MRecord(525,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is agenda input to Delete");

  }


  return MRecord(526,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfIndex v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfIndex since it is agenda input to Delete");

  }


  return MRecord(527,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is agenda input to Delete");

  }


  return MRecord(528,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPpath v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfPpath since it is agenda input to Delete");

  }


  return MRecord(529,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfPropagationMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is agenda input to Delete");

  }


  return MRecord(530,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfRadiationVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is agenda input to Delete");

  }


  return MRecord(531,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfScatteringMetaData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is agenda input to Delete");

  }


  return MRecord(532,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfSingleScatteringData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is agenda input to Delete");

  }


  return MRecord(533,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfSpeciesTag v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is agenda input to Delete");

  }


  return MRecord(534,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfStokesVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is agenda input to Delete");

  }


  return MRecord(535,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfString v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfString since it is agenda input to Delete");

  }


  return MRecord(536,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is agenda input to Delete");

  }


  return MRecord(537,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor6 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is agenda input to Delete");

  }


  return MRecord(538,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTime v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfTime since it is agenda input to Delete");

  }


  return MRecord(539,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTransmissionMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is agenda input to Delete");

  }


  return MRecord(540,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfVector since it is agenda input to Delete");

  }


  return MRecord(541,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfCIARecord v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfCIARecord since it is agenda input to Delete");

  }


  return MRecord(542,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField1 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfGriddedField1 since it is agenda input to Delete");

  }


  return MRecord(543,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField2 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfGriddedField2 since it is agenda input to Delete");

  }


  return MRecord(544,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to Delete");

  }


  return MRecord(545,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField4 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfGriddedField4 since it is agenda input to Delete");

  }


  return MRecord(546,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfIndex v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Delete");

  }


  return MRecord(547,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to Delete");

  }


  return MRecord(548,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPropagationMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfPropagationMatrix since it is agenda input to Delete");

  }


  return MRecord(549,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to Delete");

  }


  return MRecord(550,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRadiationVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfRadiationVector since it is agenda input to Delete");

  }


  return MRecord(551,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRetrievalQuantity v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is agenda input to Delete");

  }


  return MRecord(552,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfScatteringMetaData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfScatteringMetaData since it is agenda input to Delete");

  }


  return MRecord(553,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfSingleScatteringData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfSingleScatteringData since it is agenda input to Delete");

  }


  return MRecord(554,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfSparse v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfSparse since it is agenda input to Delete");

  }


  return MRecord(555,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfStokesVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfStokesVector since it is agenda input to Delete");

  }


  return MRecord(556,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfString v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfString since it is agenda input to Delete");

  }


  return MRecord(557,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTelsemAtlas v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTelsemAtlas since it is agenda input to Delete");

  }


  return MRecord(558,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor3 since it is agenda input to Delete");

  }


  return MRecord(559,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor4 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor4 since it is agenda input to Delete");

  }


  return MRecord(560,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor5 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor5 since it is agenda input to Delete");

  }


  return MRecord(561,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor6 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor6 since it is agenda input to Delete");

  }


  return MRecord(562,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor7 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor7 since it is agenda input to Delete");

  }


  return MRecord(563,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTime v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTime since it is agenda input to Delete");

  }


  return MRecord(564,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTransmissionMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is agenda input to Delete");

  }


  return MRecord(565,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfVector since it is agenda input to Delete");

  }


  return MRecord(566,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfXsecRecord v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfXsecRecord since it is agenda input to Delete");

  }


  return MRecord(567,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::CIARecord v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceCIARecord since it is agenda input to Delete");

  }


  return MRecord(568,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::CovarianceMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceCovarianceMatrix since it is agenda input to Delete");

  }


  return MRecord(569,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::EnergyLevelMap v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceEnergyLevelMap since it is agenda input to Delete");

  }


  return MRecord(570,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::GasAbsLookup v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceGasAbsLookup since it is agenda input to Delete");

  }


  return MRecord(571,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::GridPos v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceGridPos since it is agenda input to Delete");

  }


  return MRecord(572,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField1 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceGriddedField1 since it is agenda input to Delete");

  }


  return MRecord(573,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField2 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceGriddedField2 since it is agenda input to Delete");

  }


  return MRecord(574,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceGriddedField3 since it is agenda input to Delete");

  }


  return MRecord(575,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField4 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceGriddedField4 since it is agenda input to Delete");

  }


  return MRecord(576,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField5 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceGriddedField5 since it is agenda input to Delete");

  }


  return MRecord(577,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField6 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceGriddedField6 since it is agenda input to Delete");

  }


  return MRecord(578,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::HitranRelaxationMatrixData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceHitranRelaxationMatrixData since it is agenda input to Delete");

  }


  return MRecord(579,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Index v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceIndex since it is agenda input to Delete");

  }


  return MRecord(580,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::MCAntenna v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceMCAntenna since it is agenda input to Delete");

  }


  return MRecord(581,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceMatrix since it is agenda input to Delete");

  }


  return MRecord(582,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceNumeric since it is agenda input to Delete");

  }


  return MRecord(583,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Ppath v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspacePpath since it is agenda input to Delete");

  }


  return MRecord(584,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::PropagationMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspacePropagationMatrix since it is agenda input to Delete");

  }


  return MRecord(585,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to Delete");

  }


  return MRecord(586,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::RadiationVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceRadiationVector since it is agenda input to Delete");

  }


  return MRecord(587,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Rational v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceRational since it is agenda input to Delete");

  }


  return MRecord(588,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::ScatteringMetaData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceScatteringMetaData since it is agenda input to Delete");

  }


  return MRecord(589,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::SingleScatteringData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceSingleScatteringData since it is agenda input to Delete");

  }


  return MRecord(590,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Sparse v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceSparse since it is agenda input to Delete");

  }


  return MRecord(591,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::SpeciesAuxData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceSpeciesAuxData since it is agenda input to Delete");

  }


  return MRecord(592,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::StokesVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceStokesVector since it is agenda input to Delete");

  }


  return MRecord(593,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::String v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceString since it is agenda input to Delete");

  }


  return MRecord(594,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::TelsemAtlas v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTelsemAtlas since it is agenda input to Delete");

  }


  return MRecord(595,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor3 since it is agenda input to Delete");

  }


  return MRecord(596,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor4 since it is agenda input to Delete");

  }


  return MRecord(597,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor5 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor5 since it is agenda input to Delete");

  }


  return MRecord(598,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor6 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor6 since it is agenda input to Delete");

  }


  return MRecord(599,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor7 since it is agenda input to Delete");

  }


  return MRecord(600,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Timer v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTimer since it is agenda input to Delete");

  }


  return MRecord(601,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Time v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTime since it is agenda input to Delete");

  }


  return MRecord(602,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::TessemNN v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTessemNN since it is agenda input to Delete");

  }


  return MRecord(603,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::TransmissionMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTransmissionMatrix since it is agenda input to Delete");

  }


  return MRecord(604,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceVector since it is agenda input to Delete");

  }


  return MRecord(605,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Delete(

    [[maybe_unused]] Workspace& ws,

               const Var::Verbosity v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceVerbosity since it is agenda input to Delete");

  }


  return MRecord(606,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord diameter_maxFromDiameter_volume_equ(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric diameter_max,

                     Var::Numeric diameter_area_equ,

               const Var::String shape,

               const Var::Numeric diameter_volume_equ,

               const Var::Numeric aspect_ratio) {

  if (diameter_max.islast()) {

    throw std::runtime_error("diameter_max needs to be a defined WorkspaceNumeric since it is output of diameter_maxFromDiameter_volume_equ");

  } if (diameter_area_equ.islast()) {

    throw std::runtime_error("diameter_area_equ needs to be a defined WorkspaceNumeric since it is output of diameter_maxFromDiameter_volume_equ");

  } if (shape.islast()) {

    throw std::runtime_error("shape needs to be a defined WorkspaceString since it is agenda input to diameter_maxFromDiameter_volume_equ");

  } if (diameter_volume_equ.islast()) {

    throw std::runtime_error("diameter_volume_equ needs to be a defined WorkspaceNumeric since it is agenda input to diameter_maxFromDiameter_volume_equ");

  } if (aspect_ratio.islast()) {

    throw std::runtime_error("aspect_ratio needs to be a defined WorkspaceNumeric since it is agenda input to diameter_maxFromDiameter_volume_equ");

  }


  return MRecord(607,

    Group::ArrayOfIndex({Group::Index(diameter_max.pos()), Group::Index(diameter_area_equ.pos()), }),

    Group::ArrayOfIndex({Group::Index(shape.pos()), Group::Index(diameter_volume_equ.pos()), Group::Index(aspect_ratio.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord diameter_volume_equFromDiameter_max(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric diameter_volume_equ,

                     Var::Numeric volume,

               const Var::String shape,

               const Var::Numeric diameter_max,

               const Var::Numeric aspect_ratio) {

  if (diameter_volume_equ.islast()) {

    throw std::runtime_error("diameter_volume_equ needs to be a defined WorkspaceNumeric since it is output of diameter_volume_equFromDiameter_max");

  } if (volume.islast()) {

    throw std::runtime_error("volume needs to be a defined WorkspaceNumeric since it is output of diameter_volume_equFromDiameter_max");

  } if (shape.islast()) {

    throw std::runtime_error("shape needs to be a defined WorkspaceString since it is agenda input to diameter_volume_equFromDiameter_max");

  } if (diameter_max.islast()) {

    throw std::runtime_error("diameter_max needs to be a defined WorkspaceNumeric since it is agenda input to diameter_volume_equFromDiameter_max");

  } if (aspect_ratio.islast()) {

    throw std::runtime_error("aspect_ratio needs to be a defined WorkspaceNumeric since it is agenda input to diameter_volume_equFromDiameter_max");

  }


  return MRecord(608,

    Group::ArrayOfIndex({Group::Index(diameter_volume_equ.pos()), Group::Index(volume.pos()), }),

    Group::ArrayOfIndex({Group::Index(shape.pos()), Group::Index(diameter_max.pos()), Group::Index(aspect_ratio.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord DiagonalMatrix(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Vector v) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of DiagonalMatrix");

  } if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceVector since it is agenda input to DiagonalMatrix");

  }


  return MRecord(609,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord DiagonalMatrix(

    [[maybe_unused]] Workspace& ws,

                     Var::Sparse out,

               const Var::Vector v) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of DiagonalMatrix");

  } if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceVector since it is agenda input to DiagonalMatrix");

  }


  return MRecord(610,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord DiffZaAa(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix dlos,

               const Var::Vector ref_los,

               const Var::Matrix other_los) {

  if (dlos.islast()) {

    throw std::runtime_error("dlos needs to be a defined WorkspaceMatrix since it is output of DiffZaAa");

  } if (ref_los.islast()) {

    throw std::runtime_error("ref_los needs to be a defined WorkspaceVector since it is agenda input to DiffZaAa");

  } if (other_los.islast()) {

    throw std::runtime_error("other_los needs to be a defined WorkspaceMatrix since it is agenda input to DiffZaAa");

  }


  return MRecord(611,

    Group::ArrayOfIndex({Group::Index(dlos.pos()), }),

    Group::ArrayOfIndex({Group::Index(ref_los.pos()), Group::Index(other_los.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord DisortCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& nstreams={},

               const Var::String& pfct_method={},

               const Var::Index& Npfct={},

               const Var::Index& quiet={}) {

  if (not nstreams.isnull() and nstreams.islast()) {

    throw std::runtime_error("nstreams needs to be a defined WorkspaceIndex (or left default) since it is agenda input to DisortCalc");

  } if (not pfct_method.isnull() and pfct_method.islast()) {

    throw std::runtime_error("pfct_method needs to be a defined WorkspaceString (or left default) since it is agenda input to DisortCalc");

  } if (not Npfct.isnull() and Npfct.islast()) {

    throw std::runtime_error("Npfct needs to be a defined WorkspaceIndex (or left default) since it is agenda input to DisortCalc");

  } if (not quiet.isnull() and quiet.islast()) {

    throw std::runtime_error("quiet needs to be a defined WorkspaceIndex (or left default) since it is agenda input to DisortCalc");

  }


  static const auto nstreams_default = Var::IndexCreate(ws, 8,

    "DisortCalc_nstreams_autodefault",

    "auto generated variable with default from method definition");

  static const auto pfct_method_default = Var::StringCreate(ws, "median",

    "DisortCalc_pfct_method_autodefault",

    "auto generated variable with default from method definition");

  static const auto Npfct_default = Var::IndexCreate(ws, 181,

    "DisortCalc_Npfct_autodefault",

    "auto generated variable with default from method definition");

  static const auto quiet_default = Var::IndexCreate(ws, 0,

    "DisortCalc_quiet_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(612,

    Group::ArrayOfIndex({49, }),

    Group::ArrayOfIndex({36, 37, 268, 48, 53, 52, 238, 35, 213, 338, 381, 344, 242, 267, 104, 378, 306, 384, 321, 324, nstreams.isnull() ? Index(nstreams_default.pos()) : Group::Index(nstreams.pos()), pfct_method.isnull() ? Index(pfct_method_default.pos()) : Group::Index(pfct_method.pos()), Npfct.isnull() ? Index(Npfct_default.pos()) : Group::Index(Npfct.pos()), quiet.isnull() ? Index(quiet_default.pos()) : Group::Index(quiet.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord DisortCalcWithARTSSurface(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& nstreams={},

               const Var::String& pfct_method={},

               const Var::Index& Npfct={},

               const Var::Index& quiet={}) {

  if (not nstreams.isnull() and nstreams.islast()) {

    throw std::runtime_error("nstreams needs to be a defined WorkspaceIndex (or left default) since it is agenda input to DisortCalcWithARTSSurface");

  } if (not pfct_method.isnull() and pfct_method.islast()) {

    throw std::runtime_error("pfct_method needs to be a defined WorkspaceString (or left default) since it is agenda input to DisortCalcWithARTSSurface");

  } if (not Npfct.isnull() and Npfct.islast()) {

    throw std::runtime_error("Npfct needs to be a defined WorkspaceIndex (or left default) since it is agenda input to DisortCalcWithARTSSurface");

  } if (not quiet.isnull() and quiet.islast()) {

    throw std::runtime_error("quiet needs to be a defined WorkspaceIndex (or left default) since it is agenda input to DisortCalcWithARTSSurface");

  }


  static const auto nstreams_default = Var::IndexCreate(ws, 8,

    "DisortCalcWithARTSSurface_nstreams_autodefault",

    "auto generated variable with default from method definition");

  static const auto pfct_method_default = Var::StringCreate(ws, "median",

    "DisortCalcWithARTSSurface_pfct_method_autodefault",

    "auto generated variable with default from method definition");

  static const auto Npfct_default = Var::IndexCreate(ws, 181,

    "DisortCalcWithARTSSurface_Npfct_autodefault",

    "auto generated variable with default from method definition");

  static const auto quiet_default = Var::IndexCreate(ws, 0,

    "DisortCalcWithARTSSurface_quiet_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(613,

    Group::ArrayOfIndex({49, }),

    Group::ArrayOfIndex({36, 37, 268, 48, 53, 52, 238, 318, 35, 213, 338, 381, 344, 242, 267, 104, 378, 306, nstreams.isnull() ? Index(nstreams_default.pos()) : Group::Index(nstreams.pos()), pfct_method.isnull() ? Index(pfct_method_default.pos()) : Group::Index(pfct_method.pos()), Npfct.isnull() ? Index(Npfct_default.pos()) : Group::Index(Npfct.pos()), quiet.isnull() ? Index(quiet_default.pos()) : Group::Index(quiet.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord DisortCalcClearsky(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& nstreams={},

               const Var::Index& quiet={}) {

  if (not nstreams.isnull() and nstreams.islast()) {

    throw std::runtime_error("nstreams needs to be a defined WorkspaceIndex (or left default) since it is agenda input to DisortCalcClearsky");

  } if (not quiet.isnull() and quiet.islast()) {

    throw std::runtime_error("quiet needs to be a defined WorkspaceIndex (or left default) since it is agenda input to DisortCalcClearsky");

  }


  static const auto nstreams_default = Var::IndexCreate(ws, 8,

    "DisortCalcClearsky_nstreams_autodefault",

    "auto generated variable with default from method definition");

  static const auto quiet_default = Var::IndexCreate(ws, 0,

    "DisortCalcClearsky_quiet_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(614,

    Group::ArrayOfIndex({302, }),

    Group::ArrayOfIndex({36, 37, 238, 35, 338, 381, 344, 242, 104, 378, 306, 384, 321, 324, nstreams.isnull() ? Index(nstreams_default.pos()) : Group::Index(nstreams.pos()), quiet.isnull() ? Index(quiet_default.pos()) : Group::Index(quiet.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord DOBatchCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& robust={}) {

  if (not robust.isnull() and robust.islast()) {

    throw std::runtime_error("robust needs to be a defined WorkspaceIndex (or left default) since it is agenda input to DOBatchCalc");

  }


  static const auto robust_default = Var::IndexCreate(ws, 0,

    "DOBatchCalc_robust_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(615,

    Group::ArrayOfIndex({66, 67, 68, 69, }),

    Group::ArrayOfIndex({376, 375, 65, robust.isnull() ? Index(robust_default.pos()) : Group::Index(robust.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord DOAngularGridsSet(

    [[maybe_unused]] Workspace& ws,

               const Var::Index N_za_grid,

               const Var::Index& N_aa_grid={},

               const Var::String& za_grid_opt_file={}) {

  if (N_za_grid.islast()) {

    throw std::runtime_error("N_za_grid needs to be a defined WorkspaceIndex since it is agenda input to DOAngularGridsSet");

  } if (not N_aa_grid.isnull() and N_aa_grid.islast()) {

    throw std::runtime_error("N_aa_grid needs to be a defined WorkspaceIndex (or left default) since it is agenda input to DOAngularGridsSet");

  } if (not za_grid_opt_file.isnull() and za_grid_opt_file.islast()) {

    throw std::runtime_error("za_grid_opt_file needs to be a defined WorkspaceString (or left default) since it is agenda input to DOAngularGridsSet");

  }


  static const auto N_aa_grid_default = Var::IndexCreate(ws, 1,

    "DOAngularGridsSet_N_aa_grid_autodefault",

    "auto generated variable with default from method definition");

  static const auto za_grid_opt_file_default = Var::StringCreate(ws, "",

    "DOAngularGridsSet_za_grid_opt_file_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(616,

    Group::ArrayOfIndex({89, 0, 378, }),

    Group::ArrayOfIndex({Group::Index(N_za_grid.pos()), N_aa_grid.isnull() ? Index(N_aa_grid_default.pos()) : Group::Index(N_aa_grid.pos()), za_grid_opt_file.isnull() ? Index(za_grid_opt_file_default.pos()) : Group::Index(za_grid_opt_file.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord DoitCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(617,

    Group::ArrayOfIndex({49, }),

    Group::ArrayOfIndex({36, 37, 48, 268, 53, 104, 84, 82, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord DoitGetIncoming(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& rigorous={},

               const Var::Numeric& maxratio={}) {

  if (not rigorous.isnull() and rigorous.islast()) {

    throw std::runtime_error("rigorous needs to be a defined WorkspaceIndex (or left default) since it is agenda input to DoitGetIncoming");

  } if (not maxratio.isnull() and maxratio.islast()) {

    throw std::runtime_error("maxratio needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to DoitGetIncoming");

  }


  static const auto rigorous_default = Var::IndexCreate(ws, 1,

    "DoitGetIncoming_rigorous_autodefault",

    "auto generated variable with default from method definition");

  static const auto maxratio_default = Var::NumericCreate(ws, 100,

    "DoitGetIncoming_maxratio_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(618,

    Group::ArrayOfIndex({49, }),

    Group::ArrayOfIndex({36, 37, 48, 82, 127, 35, 139, 147, 381, 339, 53, 52, 104, 306, 378, 0, rigorous.isnull() ? Index(rigorous_default.pos()) : Group::Index(rigorous.pos()), maxratio.isnull() ? Index(maxratio_default.pos()) : Group::Index(maxratio.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord DoitGetIncoming1DAtm(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(619,

    Group::ArrayOfIndex({49, 53, }),

    Group::ArrayOfIndex({36, 37, 48, 82, 127, 35, 139, 147, 381, 339, 52, 104, 306, 378, 0, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord DoitInit(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(620,

    Group::ArrayOfIndex({87, 49, 82, }),

    Group::ArrayOfIndex({306, 35, 104, 378, 0, 89, 53, 52, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord DoitScatteringDataPrepare(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(621,

    Group::ArrayOfIndex({205, 270, 202, 0, }),

    Group::ArrayOfIndex({89, 267, 268, 105, 35, 306, 338, 52, 213, 204, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord DoitWriteIterationFields(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfIndex& iterations={},

               const Var::ArrayOfIndex& frequencies={}) {

  if (not iterations.isnull() and iterations.islast()) {

    throw std::runtime_error("iterations needs to be a defined WorkspaceArrayOfIndex (or left default) since it is agenda input to DoitWriteIterationFields");

  } if (not frequencies.isnull() and frequencies.islast()) {

    throw std::runtime_error("frequencies needs to be a defined WorkspaceArrayOfIndex (or left default) since it is agenda input to DoitWriteIterationFields");

  }


  static const auto iterations_default = Var::ArrayOfIndexCreate(ws, {-1},

    "DoitWriteIterationFields_iterations_autodefault",

    "auto generated variable with default from method definition");

  static const auto frequencies_default = Var::ArrayOfIndexCreate(ws, {-1},

    "DoitWriteIterationFields_frequencies_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(622,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({83, 50, 105, iterations.isnull() ? Index(iterations_default.pos()) : Group::Index(iterations.pos()), frequencies.isnull() ? Index(frequencies_default.pos()) : Group::Index(frequencies.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord doit_conv_flagAbs(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector epsilon,

               const Var::Index& max_iterations={},

               const Var::Index& nonconv_return_nan={}) {

  if (epsilon.islast()) {

    throw std::runtime_error("epsilon needs to be a defined WorkspaceVector since it is agenda input to doit_conv_flagAbs");

  } if (not max_iterations.isnull() and max_iterations.islast()) {

    throw std::runtime_error("max_iterations needs to be a defined WorkspaceIndex (or left default) since it is agenda input to doit_conv_flagAbs");

  } if (not nonconv_return_nan.isnull() and nonconv_return_nan.islast()) {

    throw std::runtime_error("nonconv_return_nan needs to be a defined WorkspaceIndex (or left default) since it is agenda input to doit_conv_flagAbs");

  }


  static const auto max_iterations_default = Var::IndexCreate(ws, 100,

    "doit_conv_flagAbs_max_iterations_autodefault",

    "auto generated variable with default from method definition");

  static const auto nonconv_return_nan_default = Var::IndexCreate(ws, 0,

    "doit_conv_flagAbs_nonconv_return_nan_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(623,

    Group::ArrayOfIndex({80, 83, 50, }),

    Group::ArrayOfIndex({51, Group::Index(epsilon.pos()), max_iterations.isnull() ? Index(max_iterations_default.pos()) : Group::Index(max_iterations.pos()), nonconv_return_nan.isnull() ? Index(nonconv_return_nan_default.pos()) : Group::Index(nonconv_return_nan.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord doit_conv_flagAbsBT(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector epsilon,

               const Var::Index& max_iterations={},

               const Var::Index& nonconv_return_nan={}) {

  if (epsilon.islast()) {

    throw std::runtime_error("epsilon needs to be a defined WorkspaceVector since it is agenda input to doit_conv_flagAbsBT");

  } if (not max_iterations.isnull() and max_iterations.islast()) {

    throw std::runtime_error("max_iterations needs to be a defined WorkspaceIndex (or left default) since it is agenda input to doit_conv_flagAbsBT");

  } if (not nonconv_return_nan.isnull() and nonconv_return_nan.islast()) {

    throw std::runtime_error("nonconv_return_nan needs to be a defined WorkspaceIndex (or left default) since it is agenda input to doit_conv_flagAbsBT");

  }


  static const auto max_iterations_default = Var::IndexCreate(ws, 100,

    "doit_conv_flagAbsBT_max_iterations_autodefault",

    "auto generated variable with default from method definition");

  static const auto nonconv_return_nan_default = Var::IndexCreate(ws, 0,

    "doit_conv_flagAbsBT_nonconv_return_nan_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(624,

    Group::ArrayOfIndex({80, 83, 50, }),

    Group::ArrayOfIndex({51, 104, 105, Group::Index(epsilon.pos()), max_iterations.isnull() ? Index(max_iterations_default.pos()) : Group::Index(max_iterations.pos()), nonconv_return_nan.isnull() ? Index(nonconv_return_nan_default.pos()) : Group::Index(nonconv_return_nan.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord doit_conv_flagLsq(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector epsilon,

               const Var::Index& max_iterations={},

               const Var::Index& nonconv_return_nan={}) {

  if (epsilon.islast()) {

    throw std::runtime_error("epsilon needs to be a defined WorkspaceVector since it is agenda input to doit_conv_flagLsq");

  } if (not max_iterations.isnull() and max_iterations.islast()) {

    throw std::runtime_error("max_iterations needs to be a defined WorkspaceIndex (or left default) since it is agenda input to doit_conv_flagLsq");

  } if (not nonconv_return_nan.isnull() and nonconv_return_nan.islast()) {

    throw std::runtime_error("nonconv_return_nan needs to be a defined WorkspaceIndex (or left default) since it is agenda input to doit_conv_flagLsq");

  }


  static const auto max_iterations_default = Var::IndexCreate(ws, 100,

    "doit_conv_flagLsq_max_iterations_autodefault",

    "auto generated variable with default from method definition");

  static const auto nonconv_return_nan_default = Var::IndexCreate(ws, 0,

    "doit_conv_flagLsq_nonconv_return_nan_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(625,

    Group::ArrayOfIndex({80, 83, 50, }),

    Group::ArrayOfIndex({51, 104, 105, Group::Index(epsilon.pos()), max_iterations.isnull() ? Index(max_iterations_default.pos()) : Group::Index(max_iterations.pos()), nonconv_return_nan.isnull() ? Index(nonconv_return_nan_default.pos()) : Group::Index(nonconv_return_nan.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord OptimizeDoitPressureGrid(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& tau_scat_max={},

               const Var::Numeric& sgl_alb_max={},

               const Var::Index& cloudbox_size_max={}) {

  if (not tau_scat_max.isnull() and tau_scat_max.islast()) {

    throw std::runtime_error("tau_scat_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to OptimizeDoitPressureGrid");

  } if (not sgl_alb_max.isnull() and sgl_alb_max.islast()) {

    throw std::runtime_error("sgl_alb_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to OptimizeDoitPressureGrid");

  } if (not cloudbox_size_max.isnull() and cloudbox_size_max.islast()) {

    throw std::runtime_error("cloudbox_size_max needs to be a defined WorkspaceIndex (or left default) since it is agenda input to OptimizeDoitPressureGrid");

  }


  static const auto tau_scat_max_default = Var::NumericCreate(ws, 0.1,

    "OptimizeDoitPressureGrid_tau_scat_max_autodefault",

    "auto generated variable with default from method definition");

  static const auto sgl_alb_max_default = Var::NumericCreate(ws, 0.9,

    "OptimizeDoitPressureGrid_sgl_alb_max_autodefault",

    "auto generated variable with default from method definition");

  static const auto cloudbox_size_max_default = Var::IndexCreate(ws, 200,

    "OptimizeDoitPressureGrid_cloudbox_size_max_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(626,

    Group::ArrayOfIndex({242, 213, 338, 270, 381, 52, 50, 202, 344, 243, }),

    Group::ArrayOfIndex({104, 105, 238, tau_scat_max.isnull() ? Index(tau_scat_max_default.pos()) : Group::Index(tau_scat_max.pos()), sgl_alb_max.isnull() ? Index(sgl_alb_max_default.pos()) : Group::Index(sgl_alb_max.pos()), cloudbox_size_max.isnull() ? Index(cloudbox_size_max_default.pos()) : Group::Index(cloudbox_size_max.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord doit_scat_fieldCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(627,

    Group::ArrayOfIndex({87, }),

    Group::ArrayOfIndex({204, 50, 213, 338, 35, 52, 378, 0, 89, 202, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord doit_scat_fieldCalcLimb(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(628,

    Group::ArrayOfIndex({87, }),

    Group::ArrayOfIndex({204, 50, 213, 338, 35, 52, 378, 0, 89, 90, 202, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord doit_za_grid_optCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric acc) {

  if (acc.islast()) {

    throw std::runtime_error("acc needs to be a defined WorkspaceNumeric since it is agenda input to doit_za_grid_optCalc");

  }


  return MRecord(629,

    Group::ArrayOfIndex({88, }),

    Group::ArrayOfIndex({50, 378, 90, Group::Index(acc.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord doit_za_interpSet(

    [[maybe_unused]] Workspace& ws,

               const Var::String& interp_method={}) {

  if (not interp_method.isnull() and interp_method.islast()) {

    throw std::runtime_error("interp_method needs to be a defined WorkspaceString (or left default) since it is agenda input to doit_za_interpSet");

  }


  static const auto interp_method_default = Var::StringCreate(ws, "linear",

    "doit_za_interpSet_interp_method_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(630,

    Group::ArrayOfIndex({90, }),

    Group::ArrayOfIndex({35, interp_method.isnull() ? Index(interp_method_default.pos()) : Group::Index(interp_method.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Duration(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric duration,

               const Var::Time start,

               const Var::Time end) {

  if (duration.islast()) {

    throw std::runtime_error("duration needs to be a defined WorkspaceNumeric since it is output of Duration");

  } if (start.islast()) {

    throw std::runtime_error("start needs to be a defined WorkspaceTime since it is agenda input to Duration");

  } if (end.islast()) {

    throw std::runtime_error("end needs to be a defined WorkspaceTime since it is agenda input to Duration");

  }


  return MRecord(631,

    Group::ArrayOfIndex({Group::Index(duration.pos()), }),

    Group::ArrayOfIndex({Group::Index(start.pos()), Group::Index(end.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord EnergyLevelMapSet(

    [[maybe_unused]] Workspace& ws,

                     Var::EnergyLevelMap x,

               const Var::EnergyLevelMap y) {

  if (x.islast()) {

    throw std::runtime_error("x needs to be a defined WorkspaceEnergyLevelMap since it is output of EnergyLevelMapSet");

  } if (y.islast()) {

    throw std::runtime_error("y needs to be a defined WorkspaceEnergyLevelMap since it is agenda input to EnergyLevelMapSet");

  }


  return MRecord(632,

    Group::ArrayOfIndex({Group::Index(x.pos()), }),

    Group::ArrayOfIndex({Group::Index(y.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Error(

    [[maybe_unused]] Workspace& ws,

               const Var::String msg) {

  if (msg.islast()) {

    throw std::runtime_error("msg needs to be a defined WorkspaceString since it is agenda input to Error");

  }


  return MRecord(633,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(msg.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Exit(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(634,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::Index needle,

               const Var::ArrayOfIndex haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceIndex since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(635,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfIndex needle,

               const Var::ArrayOfArrayOfIndex haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceArrayOfIndex since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfIndex since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(636,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric needle,

               const Var::Vector haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceNumeric since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceVector since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(637,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector needle,

               const Var::ArrayOfVector haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceVector since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfVector since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(638,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix needle,

               const Var::ArrayOfMatrix haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceMatrix since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(639,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix needle,

               const Var::Tensor3 haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceMatrix since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceTensor3 since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(640,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 needle,

               const Var::Tensor4 haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceTensor3 since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceTensor4 since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(641,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 needle,

               const Var::ArrayOfTensor4 haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceTensor4 since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfTensor4 since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(642,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 needle,

               const Var::Tensor5 haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceTensor4 since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceTensor5 since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(643,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField3 needle,

               const Var::ArrayOfGriddedField3 haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceGriddedField3 since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(644,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField3 needle,

               const Var::ArrayOfArrayOfGriddedField3 haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(645,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField4 needle,

               const Var::ArrayOfGriddedField4 haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceGriddedField4 since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfGriddedField4 since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(646,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::String needle,

               const Var::ArrayOfString haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceString since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfString since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(647,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::SingleScatteringData needle,

               const Var::ArrayOfSingleScatteringData haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceSingleScatteringData since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfSingleScatteringData since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(648,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSingleScatteringData needle,

               const Var::ArrayOfArrayOfSingleScatteringData haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(649,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::TelsemAtlas needle,

               const Var::ArrayOfTelsemAtlas haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceTelsemAtlas since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfTelsemAtlas since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(650,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Extract(

    [[maybe_unused]] Workspace& ws,

                     Var::QuantumIdentifier needle,

               const Var::ArrayOfQuantumIdentifier haystack,

               const Var::Index index) {

  if (needle.islast()) {

    throw std::runtime_error("needle needs to be a defined WorkspaceQuantumIdentifier since it is output of Extract");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to Extract");

  } if (index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex since it is agenda input to Extract");

  }


  return MRecord(651,

    Group::ArrayOfIndex({Group::Index(needle.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ExtractFromMetaSingleScatSpecies(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector meta_param,

               const Var::String meta_name,

               const Var::Index scat_species_index) {

  if (meta_param.islast()) {

    throw std::runtime_error("meta_param needs to be a defined WorkspaceVector since it is output of ExtractFromMetaSingleScatSpecies");

  } if (meta_name.islast()) {

    throw std::runtime_error("meta_name needs to be a defined WorkspaceString since it is agenda input to ExtractFromMetaSingleScatSpecies");

  } if (scat_species_index.islast()) {

    throw std::runtime_error("scat_species_index needs to be a defined WorkspaceIndex since it is agenda input to ExtractFromMetaSingleScatSpecies");

  }


  return MRecord(652,

    Group::ArrayOfIndex({Group::Index(meta_param.pos()), }),

    Group::ArrayOfIndex({275, Group::Index(meta_name.pos()), Group::Index(scat_species_index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ext_matAddGas(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(653,

    Group::ArrayOfIndex({95, }),

    Group::ArrayOfIndex({236, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord FastemStandAlone(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix emissivity,

                     Var::Matrix reflectivity,

               const Var::Numeric za,

               const Var::Numeric wind_speed,

               const Var::Numeric rel_aa,

               const Var::Vector transmittance,

               const Var::Numeric& salinity={},

               const Var::Index& fastem_version={}) {

  if (emissivity.islast()) {

    throw std::runtime_error("emissivity needs to be a defined WorkspaceMatrix since it is output of FastemStandAlone");

  } if (reflectivity.islast()) {

    throw std::runtime_error("reflectivity needs to be a defined WorkspaceMatrix since it is output of FastemStandAlone");

  } if (za.islast()) {

    throw std::runtime_error("za needs to be a defined WorkspaceNumeric since it is agenda input to FastemStandAlone");

  } if (not salinity.isnull() and salinity.islast()) {

    throw std::runtime_error("salinity needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to FastemStandAlone");

  } if (wind_speed.islast()) {

    throw std::runtime_error("wind_speed needs to be a defined WorkspaceNumeric since it is agenda input to FastemStandAlone");

  } if (rel_aa.islast()) {

    throw std::runtime_error("rel_aa needs to be a defined WorkspaceNumeric since it is agenda input to FastemStandAlone");

  } if (transmittance.islast()) {

    throw std::runtime_error("transmittance needs to be a defined WorkspaceVector since it is agenda input to FastemStandAlone");

  } if (not fastem_version.isnull() and fastem_version.islast()) {

    throw std::runtime_error("fastem_version needs to be a defined WorkspaceIndex (or left default) since it is agenda input to FastemStandAlone");

  }


  static const auto salinity_default = Var::NumericCreate(ws, 0.035,

    "FastemStandAlone_salinity_autodefault",

    "auto generated variable with default from method definition");

  static const auto fastem_version_default = Var::IndexCreate(ws, 6,

    "FastemStandAlone_fastem_version_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(654,

    Group::ArrayOfIndex({Group::Index(emissivity.pos()), Group::Index(reflectivity.pos()), }),

    Group::ArrayOfIndex({104, 321, Group::Index(za.pos()), salinity.isnull() ? Index(salinity_default.pos()) : Group::Index(salinity.pos()), Group::Index(wind_speed.pos()), Group::Index(rel_aa.pos()), Group::Index(transmittance.pos()), fastem_version.isnull() ? Index(fastem_version_default.pos()) : Group::Index(fastem_version.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord FieldFromGriddedField(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::GriddedField2 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of FieldFromGriddedField");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField2 since it is agenda input to FieldFromGriddedField");

  }


  return MRecord(655,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({242, 139, 147, Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord FieldFromGriddedField(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 out,

               const Var::GriddedField3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of FieldFromGriddedField");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField3 since it is agenda input to FieldFromGriddedField");

  }


  return MRecord(656,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({242, 139, 147, Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord FieldFromGriddedField(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 out,

               const Var::GriddedField4 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of FieldFromGriddedField");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField4 since it is agenda input to FieldFromGriddedField");

  }


  return MRecord(657,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({242, 139, 147, Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord FieldFromGriddedField(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 out,

               const Var::ArrayOfGriddedField3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of FieldFromGriddedField");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to FieldFromGriddedField");

  }


  return MRecord(658,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({242, 139, 147, Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord FlagOff(

    [[maybe_unused]] Workspace& ws,

                     Var::Index flag) {

  if (flag.islast()) {

    throw std::runtime_error("flag needs to be a defined WorkspaceIndex since it is output of FlagOff");

  }


  return MRecord(659,

    Group::ArrayOfIndex({Group::Index(flag.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord FlagOn(

    [[maybe_unused]] Workspace& ws,

                     Var::Index flag) {

  if (flag.islast()) {

    throw std::runtime_error("flag needs to be a defined WorkspaceIndex since it is output of FlagOn");

  }


  return MRecord(660,

    Group::ArrayOfIndex({Group::Index(flag.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Flatten(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTime out,

               const Var::ArrayOfArrayOfTime in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTime since it is output of Flatten");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTime since it is agenda input to Flatten");

  }


  return MRecord(661,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Flatten(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfVector out,

               const Var::ArrayOfArrayOfVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of Flatten");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfVector since it is agenda input to Flatten");

  }


  return MRecord(662,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Flatten(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::ArrayOfVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Flatten");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfVector since it is agenda input to Flatten");

  }


  return MRecord(663,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Flatten(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 out,

               const Var::ArrayOfMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Flatten");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to Flatten");

  }


  return MRecord(664,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Flatten(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 out,

               const Var::ArrayOfTensor3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of Flatten");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor3 since it is agenda input to Flatten");

  }


  return MRecord(665,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Flatten(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor5 out,

               const Var::ArrayOfTensor4 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor5 since it is output of Flatten");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor4 since it is agenda input to Flatten");

  }


  return MRecord(666,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Flatten(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor6 out,

               const Var::ArrayOfTensor5 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor6 since it is output of Flatten");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor5 since it is agenda input to Flatten");

  }


  return MRecord(667,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Flatten(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor7 out,

               const Var::ArrayOfTensor6 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor7 since it is output of Flatten");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor6 since it is agenda input to Flatten");

  }


  return MRecord(668,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ForLoop(

    [[maybe_unused]] Workspace& ws,

               const Var::Index start,

               const Var::Index stop,

               const Var::Index step) {

  if (start.islast()) {

    throw std::runtime_error("start needs to be a defined WorkspaceIndex since it is agenda input to ForLoop");

  } if (stop.islast()) {

    throw std::runtime_error("stop needs to be a defined WorkspaceIndex since it is agenda input to ForLoop");

  } if (step.islast()) {

    throw std::runtime_error("step needs to be a defined WorkspaceIndex since it is agenda input to ForLoop");

  }


  return MRecord(669,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({98, Group::Index(start.pos()), Group::Index(stop.pos()), Group::Index(step.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord FrequencyFromWavelength(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric frequency,

               const Var::Numeric wavelength) {

  if (frequency.islast()) {

    throw std::runtime_error("frequency needs to be a defined WorkspaceNumeric since it is output of FrequencyFromWavelength");

  } if (wavelength.islast()) {

    throw std::runtime_error("wavelength needs to be a defined WorkspaceNumeric since it is agenda input to FrequencyFromWavelength");

  }


  return MRecord(670,

    Group::ArrayOfIndex({Group::Index(frequency.pos()), }),

    Group::ArrayOfIndex({Group::Index(wavelength.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord FrequencyFromWavelength(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector frequency,

               const Var::Vector wavelength) {

  if (frequency.islast()) {

    throw std::runtime_error("frequency needs to be a defined WorkspaceVector since it is output of FrequencyFromWavelength");

  } if (wavelength.islast()) {

    throw std::runtime_error("wavelength needs to be a defined WorkspaceVector since it is agenda input to FrequencyFromWavelength");

  }


  return MRecord(671,

    Group::ArrayOfIndex({Group::Index(frequency.pos()), }),

    Group::ArrayOfIndex({Group::Index(wavelength.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord FrequencyFromCGSAngularWavenumber(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric frequency,

               const Var::Numeric angular_wavenumber) {

  if (frequency.islast()) {

    throw std::runtime_error("frequency needs to be a defined WorkspaceNumeric since it is output of FrequencyFromCGSAngularWavenumber");

  } if (angular_wavenumber.islast()) {

    throw std::runtime_error("angular_wavenumber needs to be a defined WorkspaceNumeric since it is agenda input to FrequencyFromCGSAngularWavenumber");

  }


  return MRecord(672,

    Group::ArrayOfIndex({Group::Index(frequency.pos()), }),

    Group::ArrayOfIndex({Group::Index(angular_wavenumber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord FrequencyFromCGSAngularWavenumber(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector frequency,

               const Var::Vector angular_wavenumber) {

  if (frequency.islast()) {

    throw std::runtime_error("frequency needs to be a defined WorkspaceVector since it is output of FrequencyFromCGSAngularWavenumber");

  } if (angular_wavenumber.islast()) {

    throw std::runtime_error("angular_wavenumber needs to be a defined WorkspaceVector since it is agenda input to FrequencyFromCGSAngularWavenumber");

  }


  return MRecord(673,

    Group::ArrayOfIndex({Group::Index(frequency.pos()), }),

    Group::ArrayOfIndex({Group::Index(angular_wavenumber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord FrequencyFromCGSKayserWavenumber(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric frequency,

               const Var::Numeric kayser_wavenumber) {

  if (frequency.islast()) {

    throw std::runtime_error("frequency needs to be a defined WorkspaceNumeric since it is output of FrequencyFromCGSKayserWavenumber");

  } if (kayser_wavenumber.islast()) {

    throw std::runtime_error("kayser_wavenumber needs to be a defined WorkspaceNumeric since it is agenda input to FrequencyFromCGSKayserWavenumber");

  }


  return MRecord(674,

    Group::ArrayOfIndex({Group::Index(frequency.pos()), }),

    Group::ArrayOfIndex({Group::Index(kayser_wavenumber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord FrequencyFromCGSKayserWavenumber(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector frequency,

               const Var::Vector kayser_wavenumber) {

  if (frequency.islast()) {

    throw std::runtime_error("frequency needs to be a defined WorkspaceVector since it is output of FrequencyFromCGSKayserWavenumber");

  } if (kayser_wavenumber.islast()) {

    throw std::runtime_error("kayser_wavenumber needs to be a defined WorkspaceVector since it is agenda input to FrequencyFromCGSKayserWavenumber");

  }


  return MRecord(675,

    Group::ArrayOfIndex({Group::Index(frequency.pos()), }),

    Group::ArrayOfIndex({Group::Index(kayser_wavenumber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord f_gridFromAbsorptionLines(

    [[maybe_unused]] Workspace& ws,

               const Var::Index num_freqs,

               const Var::Numeric& delta_f_low={},

               const Var::Numeric& delta_f_upp={}) {

  if (not delta_f_low.isnull() and delta_f_low.islast()) {

    throw std::runtime_error("delta_f_low needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to f_gridFromAbsorptionLines");

  } if (not delta_f_upp.isnull() and delta_f_upp.islast()) {

    throw std::runtime_error("delta_f_upp needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to f_gridFromAbsorptionLines");

  } if (num_freqs.islast()) {

    throw std::runtime_error("num_freqs needs to be a defined WorkspaceIndex since it is agenda input to f_gridFromAbsorptionLines");

  }


  static const auto delta_f_low_default = Var::NumericCreate(ws, -5e6,

    "f_gridFromAbsorptionLines_delta_f_low_autodefault",

    "auto generated variable with default from method definition");

  static const auto delta_f_upp_default = Var::NumericCreate(ws, 5e6,

    "f_gridFromAbsorptionLines_delta_f_upp_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(676,

    Group::ArrayOfIndex({104, }),

    Group::ArrayOfIndex({11, delta_f_low.isnull() ? Index(delta_f_low_default.pos()) : Group::Index(delta_f_low.pos()), delta_f_upp.isnull() ? Index(delta_f_upp_default.pos()) : Group::Index(delta_f_upp.pos()), Group::Index(num_freqs.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord f_gridFromGasAbsLookup(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(677,

    Group::ArrayOfIndex({104, }),

    Group::ArrayOfIndex({12, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord f_gridFromSensorAMSU(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& spacing={}) {

  if (not spacing.isnull() and spacing.islast()) {

    throw std::runtime_error("spacing needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to f_gridFromSensorAMSU");

  }


  static const auto spacing_default = Var::NumericCreate(ws, .1e9,

    "f_gridFromSensorAMSU_spacing_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(678,

    Group::ArrayOfIndex({104, }),

    Group::ArrayOfIndex({145, 103, 41, spacing.isnull() ? Index(spacing_default.pos()) : Group::Index(spacing.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord f_gridFromSensorAMSUgeneric(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& spacing={},

               const Var::Vector& verbosityVect={}) {

  if (not spacing.isnull() and spacing.islast()) {

    throw std::runtime_error("spacing needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to f_gridFromSensorAMSUgeneric");

  } if (not verbosityVect.isnull() and verbosityVect.islast()) {

    throw std::runtime_error("verbosityVect needs to be a defined WorkspaceVector (or left default) since it is agenda input to f_gridFromSensorAMSUgeneric");

  }


  static const auto spacing_default = Var::NumericCreate(ws, .1e9,

    "f_gridFromSensorAMSUgeneric_spacing_autodefault",

    "auto generated variable with default from method definition");

  static const auto verbosityVect_default = Var::VectorCreate(ws, {},

    "f_gridFromSensorAMSUgeneric_verbosityVect_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(679,

    Group::ArrayOfIndex({104, }),

    Group::ArrayOfIndex({103, 41, spacing.isnull() ? Index(spacing_default.pos()) : Group::Index(spacing.pos()), verbosityVect.isnull() ? Index(verbosityVect_default.pos()) : Group::Index(verbosityVect.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord f_gridFromSensorHIRS(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& spacing={}) {

  if (not spacing.isnull() and spacing.islast()) {

    throw std::runtime_error("spacing needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to f_gridFromSensorHIRS");

  }


  static const auto spacing_default = Var::NumericCreate(ws, 5e8,

    "f_gridFromSensorHIRS_spacing_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(680,

    Group::ArrayOfIndex({104, }),

    Group::ArrayOfIndex({102, 40, spacing.isnull() ? Index(spacing_default.pos()) : Group::Index(spacing.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord f_gridMetMM(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector& freq_spacing={},

               const Var::ArrayOfIndex& freq_number={},

               const Var::Numeric& freq_merge_threshold={}) {

  if (not freq_spacing.isnull() and freq_spacing.islast()) {

    throw std::runtime_error("freq_spacing needs to be a defined WorkspaceVector (or left default) since it is agenda input to f_gridMetMM");

  } if (not freq_number.isnull() and freq_number.islast()) {

    throw std::runtime_error("freq_number needs to be a defined WorkspaceArrayOfIndex (or left default) since it is agenda input to f_gridMetMM");

  } if (not freq_merge_threshold.isnull() and freq_merge_threshold.islast()) {

    throw std::runtime_error("freq_merge_threshold needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to f_gridMetMM");

  }


  static const auto freq_spacing_default = Var::VectorCreate(ws, {.1e9},

    "f_gridMetMM_freq_spacing_autodefault",

    "auto generated variable with default from method definition");

  static const auto freq_number_default = Var::ArrayOfIndexCreate(ws, {-1},

    "f_gridMetMM_freq_number_autodefault",

    "auto generated variable with default from method definition");

  static const auto freq_merge_threshold_default = Var::NumericCreate(ws, 1,

    "f_gridMetMM_freq_merge_threshold_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(681,

    Group::ArrayOfIndex({104, 102, 46, 47, }),

    Group::ArrayOfIndex({174, freq_spacing.isnull() ? Index(freq_spacing_default.pos()) : Group::Index(freq_spacing.pos()), freq_number.isnull() ? Index(freq_number_default.pos()) : Group::Index(freq_number.pos()), freq_merge_threshold.isnull() ? Index(freq_merge_threshold_default.pos()) : Group::Index(freq_merge_threshold.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord g0Earth(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(682,

    Group::ArrayOfIndex({107, }),

    Group::ArrayOfIndex({138, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord g0Io(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(683,

    Group::ArrayOfIndex({107, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord g0Jupiter(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(684,

    Group::ArrayOfIndex({107, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord g0Mars(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(685,

    Group::ArrayOfIndex({107, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord g0Venus(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(686,

    Group::ArrayOfIndex({107, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord geo_posEndOfPpath(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(687,

    Group::ArrayOfIndex({106, }),

    Group::ArrayOfIndex({216, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord geo_posLowestAltitudeOfPpath(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(688,

    Group::ArrayOfIndex({106, }),

    Group::ArrayOfIndex({216, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord geo_posWherePpathPassesZref(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric z_ref) {

  if (z_ref.islast()) {

    throw std::runtime_error("z_ref needs to be a defined WorkspaceNumeric since it is agenda input to geo_posWherePpathPassesZref");

  }


  return MRecord(689,

    Group::ArrayOfIndex({106, }),

    Group::ArrayOfIndex({216, Group::Index(z_ref.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GetEnvironmentVariable(

    [[maybe_unused]] Workspace& ws,

                     Var::String out,

               const Var::String in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceString since it is output of GetEnvironmentVariable");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceString since it is agenda input to GetEnvironmentVariable");

  }


  return MRecord(690,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GetEnvironmentVariable(

    [[maybe_unused]] Workspace& ws,

                     Var::Index out,

               const Var::String in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of GetEnvironmentVariable");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceString since it is agenda input to GetEnvironmentVariable");

  }


  return MRecord(691,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GetNumberOfThreads(

    [[maybe_unused]] Workspace& ws,

                     Var::Index nthreads) {

  if (nthreads.islast()) {

    throw std::runtime_error("nthreads needs to be a defined WorkspaceIndex since it is output of GetNumberOfThreads");

  }


  return MRecord(692,

    Group::ArrayOfIndex({Group::Index(nthreads.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldGetName(

    [[maybe_unused]] Workspace& ws,

                     Var::String name,

               const Var::GriddedField1 griddedfield) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is output of GriddedFieldGetName");

  } if (griddedfield.islast()) {

    throw std::runtime_error("griddedfield needs to be a defined WorkspaceGriddedField1 since it is agenda input to GriddedFieldGetName");

  }


  return MRecord(693,

    Group::ArrayOfIndex({Group::Index(name.pos()), }),

    Group::ArrayOfIndex({Group::Index(griddedfield.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldGetName(

    [[maybe_unused]] Workspace& ws,

                     Var::String name,

               const Var::GriddedField2 griddedfield) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is output of GriddedFieldGetName");

  } if (griddedfield.islast()) {

    throw std::runtime_error("griddedfield needs to be a defined WorkspaceGriddedField2 since it is agenda input to GriddedFieldGetName");

  }


  return MRecord(694,

    Group::ArrayOfIndex({Group::Index(name.pos()), }),

    Group::ArrayOfIndex({Group::Index(griddedfield.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldGetName(

    [[maybe_unused]] Workspace& ws,

                     Var::String name,

               const Var::GriddedField3 griddedfield) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is output of GriddedFieldGetName");

  } if (griddedfield.islast()) {

    throw std::runtime_error("griddedfield needs to be a defined WorkspaceGriddedField3 since it is agenda input to GriddedFieldGetName");

  }


  return MRecord(695,

    Group::ArrayOfIndex({Group::Index(name.pos()), }),

    Group::ArrayOfIndex({Group::Index(griddedfield.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldGetName(

    [[maybe_unused]] Workspace& ws,

                     Var::String name,

               const Var::GriddedField4 griddedfield) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is output of GriddedFieldGetName");

  } if (griddedfield.islast()) {

    throw std::runtime_error("griddedfield needs to be a defined WorkspaceGriddedField4 since it is agenda input to GriddedFieldGetName");

  }


  return MRecord(696,

    Group::ArrayOfIndex({Group::Index(name.pos()), }),

    Group::ArrayOfIndex({Group::Index(griddedfield.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldGetName(

    [[maybe_unused]] Workspace& ws,

                     Var::String name,

               const Var::GriddedField5 griddedfield) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is output of GriddedFieldGetName");

  } if (griddedfield.islast()) {

    throw std::runtime_error("griddedfield needs to be a defined WorkspaceGriddedField5 since it is agenda input to GriddedFieldGetName");

  }


  return MRecord(697,

    Group::ArrayOfIndex({Group::Index(name.pos()), }),

    Group::ArrayOfIndex({Group::Index(griddedfield.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldGetName(

    [[maybe_unused]] Workspace& ws,

                     Var::String name,

               const Var::GriddedField6 griddedfield) {

  if (name.islast()) {

    throw std::runtime_error("name needs to be a defined WorkspaceString since it is output of GriddedFieldGetName");

  } if (griddedfield.islast()) {

    throw std::runtime_error("griddedfield needs to be a defined WorkspaceGriddedField6 since it is agenda input to GriddedFieldGetName");

  }


  return MRecord(698,

    Group::ArrayOfIndex({Group::Index(name.pos()), }),

    Group::ArrayOfIndex({Group::Index(griddedfield.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldLatLonExpand(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField2 out,

               const Var::GriddedField2 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField2 since it is output of GriddedFieldLatLonExpand");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField2 since it is agenda input to GriddedFieldLatLonExpand");

  }


  return MRecord(699,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldLatLonExpand(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField3 out,

               const Var::GriddedField3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField3 since it is output of GriddedFieldLatLonExpand");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField3 since it is agenda input to GriddedFieldLatLonExpand");

  }


  return MRecord(700,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldLatLonExpand(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField4 out,

               const Var::GriddedField4 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField4 since it is output of GriddedFieldLatLonExpand");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField4 since it is agenda input to GriddedFieldLatLonExpand");

  }


  return MRecord(701,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldLatLonExpand(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField3 out,

               const Var::ArrayOfGriddedField3 in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of GriddedFieldLatLonExpand");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to GriddedFieldLatLonExpand");

  }


  return MRecord(702,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldLatLonRegrid(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField2 out,

               const Var::GriddedField2 in,

               const Var::Index& interp_order={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField2 since it is output of GriddedFieldLatLonRegrid");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField2 since it is agenda input to GriddedFieldLatLonRegrid");

  } if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to GriddedFieldLatLonRegrid");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "GriddedFieldLatLonRegrid_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(703,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({140, 148, Group::Index(in.pos()), interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldLatLonRegrid(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField3 out,

               const Var::GriddedField3 in,

               const Var::Index& interp_order={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField3 since it is output of GriddedFieldLatLonRegrid");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField3 since it is agenda input to GriddedFieldLatLonRegrid");

  } if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to GriddedFieldLatLonRegrid");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "GriddedFieldLatLonRegrid_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(704,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({140, 148, Group::Index(in.pos()), interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldLatLonRegrid(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField4 out,

               const Var::GriddedField4 in,

               const Var::Index& interp_order={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField4 since it is output of GriddedFieldLatLonRegrid");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField4 since it is agenda input to GriddedFieldLatLonRegrid");

  } if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to GriddedFieldLatLonRegrid");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "GriddedFieldLatLonRegrid_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(705,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({140, 148, Group::Index(in.pos()), interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldLatLonRegrid(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField3 out,

               const Var::ArrayOfGriddedField3 in,

               const Var::Index& interp_order={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of GriddedFieldLatLonRegrid");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to GriddedFieldLatLonRegrid");

  } if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to GriddedFieldLatLonRegrid");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "GriddedFieldLatLonRegrid_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(706,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({140, 148, Group::Index(in.pos()), interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldPRegrid(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField3 out,

               const Var::GriddedField3 in,

               const Var::Index& interp_order={},

               const Var::Index& zeropadding={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField3 since it is output of GriddedFieldPRegrid");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField3 since it is agenda input to GriddedFieldPRegrid");

  } if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to GriddedFieldPRegrid");

  } if (not zeropadding.isnull() and zeropadding.islast()) {

    throw std::runtime_error("zeropadding needs to be a defined WorkspaceIndex (or left default) since it is agenda input to GriddedFieldPRegrid");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "GriddedFieldPRegrid_interp_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto zeropadding_default = Var::IndexCreate(ws, 0,

    "GriddedFieldPRegrid_zeropadding_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(707,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({242, Group::Index(in.pos()), interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), zeropadding.isnull() ? Index(zeropadding_default.pos()) : Group::Index(zeropadding.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldPRegrid(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField4 out,

               const Var::GriddedField4 in,

               const Var::Index& interp_order={},

               const Var::Index& zeropadding={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField4 since it is output of GriddedFieldPRegrid");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField4 since it is agenda input to GriddedFieldPRegrid");

  } if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to GriddedFieldPRegrid");

  } if (not zeropadding.isnull() and zeropadding.islast()) {

    throw std::runtime_error("zeropadding needs to be a defined WorkspaceIndex (or left default) since it is agenda input to GriddedFieldPRegrid");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "GriddedFieldPRegrid_interp_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto zeropadding_default = Var::IndexCreate(ws, 0,

    "GriddedFieldPRegrid_zeropadding_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(708,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({242, Group::Index(in.pos()), interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), zeropadding.isnull() ? Index(zeropadding_default.pos()) : Group::Index(zeropadding.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldPRegrid(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField3 out,

               const Var::ArrayOfGriddedField3 in,

               const Var::Index& interp_order={},

               const Var::Index& zeropadding={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of GriddedFieldPRegrid");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to GriddedFieldPRegrid");

  } if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to GriddedFieldPRegrid");

  } if (not zeropadding.isnull() and zeropadding.islast()) {

    throw std::runtime_error("zeropadding needs to be a defined WorkspaceIndex (or left default) since it is agenda input to GriddedFieldPRegrid");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "GriddedFieldPRegrid_interp_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto zeropadding_default = Var::IndexCreate(ws, 0,

    "GriddedFieldPRegrid_zeropadding_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(709,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({242, Group::Index(in.pos()), interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), zeropadding.isnull() ? Index(zeropadding_default.pos()) : Group::Index(zeropadding.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord GriddedFieldZToPRegrid(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField3 out,

               const Var::GriddedField3 in,

               const Var::Index& interp_order={},

               const Var::Index& zeropadding={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField3 since it is output of GriddedFieldZToPRegrid");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField3 since it is agenda input to GriddedFieldZToPRegrid");

  } if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to GriddedFieldZToPRegrid");

  } if (not zeropadding.isnull() and zeropadding.islast()) {

    throw std::runtime_error("zeropadding needs to be a defined WorkspaceIndex (or left default) since it is agenda input to GriddedFieldZToPRegrid");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "GriddedFieldZToPRegrid_interp_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto zeropadding_default = Var::IndexCreate(ws, 0,

    "GriddedFieldZToPRegrid_zeropadding_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(710,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({242, 139, 147, 381, Group::Index(in.pos()), interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), zeropadding.isnull() ? Index(zeropadding_default.pos()) : Group::Index(zeropadding.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord heating_ratesFromIrradiance(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(711,

    Group::ArrayOfIndex({110, }),

    Group::ArrayOfIndex({242, 116, 303, 107, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::AbsorptionLines in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAbsorptionLines since it is agenda input to Ignore");

  }


  return MRecord(712,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Agenda in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAgenda since it is agenda input to Ignore");

  }


  return MRecord(713,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAbsorptionLines in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAbsorptionLines since it is agenda input to Ignore");

  }


  return MRecord(714,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfAbsorptionLines in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is agenda input to Ignore");

  }


  return MRecord(715,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAgenda in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAgenda since it is agenda input to Ignore");

  }


  return MRecord(716,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField1 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is agenda input to Ignore");

  }


  return MRecord(717,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField2 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is agenda input to Ignore");

  }


  return MRecord(718,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is agenda input to Ignore");

  }


  return MRecord(719,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfIndex in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfIndex since it is agenda input to Ignore");

  }


  return MRecord(720,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is agenda input to Ignore");

  }


  return MRecord(721,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPpath in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPpath since it is agenda input to Ignore");

  }


  return MRecord(722,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfPropagationMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is agenda input to Ignore");

  }


  return MRecord(723,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfRadiationVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is agenda input to Ignore");

  }


  return MRecord(724,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfScatteringMetaData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is agenda input to Ignore");

  }


  return MRecord(725,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfSingleScatteringData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is agenda input to Ignore");

  }


  return MRecord(726,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfSpeciesTag in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is agenda input to Ignore");

  }


  return MRecord(727,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfStokesVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is agenda input to Ignore");

  }


  return MRecord(728,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfString in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfString since it is agenda input to Ignore");

  }


  return MRecord(729,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is agenda input to Ignore");

  }


  return MRecord(730,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor6 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is agenda input to Ignore");

  }


  return MRecord(731,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTime in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTime since it is agenda input to Ignore");

  }


  return MRecord(732,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTransmissionMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is agenda input to Ignore");

  }


  return MRecord(733,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfVector since it is agenda input to Ignore");

  }


  return MRecord(734,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfCIARecord in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfCIARecord since it is agenda input to Ignore");

  }


  return MRecord(735,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField1 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField1 since it is agenda input to Ignore");

  }


  return MRecord(736,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField2 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField2 since it is agenda input to Ignore");

  }


  return MRecord(737,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to Ignore");

  }


  return MRecord(738,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField4 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField4 since it is agenda input to Ignore");

  }


  return MRecord(739,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfIndex in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Ignore");

  }


  return MRecord(740,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to Ignore");

  }


  return MRecord(741,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPropagationMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPropagationMatrix since it is agenda input to Ignore");

  }


  return MRecord(742,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to Ignore");

  }


  return MRecord(743,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRadiationVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRadiationVector since it is agenda input to Ignore");

  }


  return MRecord(744,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRetrievalQuantity in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is agenda input to Ignore");

  }


  return MRecord(745,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfScatteringMetaData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfScatteringMetaData since it is agenda input to Ignore");

  }


  return MRecord(746,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfSingleScatteringData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSingleScatteringData since it is agenda input to Ignore");

  }


  return MRecord(747,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfSparse in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSparse since it is agenda input to Ignore");

  }


  return MRecord(748,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfStokesVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfStokesVector since it is agenda input to Ignore");

  }


  return MRecord(749,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfString in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfString since it is agenda input to Ignore");

  }


  return MRecord(750,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTelsemAtlas in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTelsemAtlas since it is agenda input to Ignore");

  }


  return MRecord(751,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor3 since it is agenda input to Ignore");

  }


  return MRecord(752,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor4 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor4 since it is agenda input to Ignore");

  }


  return MRecord(753,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor5 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor5 since it is agenda input to Ignore");

  }


  return MRecord(754,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor6 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor6 since it is agenda input to Ignore");

  }


  return MRecord(755,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor7 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor7 since it is agenda input to Ignore");

  }


  return MRecord(756,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTime in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTime since it is agenda input to Ignore");

  }


  return MRecord(757,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTransmissionMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is agenda input to Ignore");

  }


  return MRecord(758,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfVector since it is agenda input to Ignore");

  }


  return MRecord(759,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfXsecRecord in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfXsecRecord since it is agenda input to Ignore");

  }


  return MRecord(760,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::CIARecord in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCIARecord since it is agenda input to Ignore");

  }


  return MRecord(761,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::CovarianceMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCovarianceMatrix since it is agenda input to Ignore");

  }


  return MRecord(762,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::EnergyLevelMap in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceEnergyLevelMap since it is agenda input to Ignore");

  }


  return MRecord(763,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::GasAbsLookup in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGasAbsLookup since it is agenda input to Ignore");

  }


  return MRecord(764,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::GridPos in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGridPos since it is agenda input to Ignore");

  }


  return MRecord(765,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField1 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField1 since it is agenda input to Ignore");

  }


  return MRecord(766,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField2 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField2 since it is agenda input to Ignore");

  }


  return MRecord(767,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField3 since it is agenda input to Ignore");

  }


  return MRecord(768,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField4 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField4 since it is agenda input to Ignore");

  }


  return MRecord(769,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField5 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField5 since it is agenda input to Ignore");

  }


  return MRecord(770,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField6 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField6 since it is agenda input to Ignore");

  }


  return MRecord(771,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::HitranRelaxationMatrixData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceHitranRelaxationMatrixData since it is agenda input to Ignore");

  }


  return MRecord(772,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Index in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceIndex since it is agenda input to Ignore");

  }


  return MRecord(773,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::MCAntenna in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMCAntenna since it is agenda input to Ignore");

  }


  return MRecord(774,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is agenda input to Ignore");

  }


  return MRecord(775,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceNumeric since it is agenda input to Ignore");

  }


  return MRecord(776,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Ppath in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePpath since it is agenda input to Ignore");

  }


  return MRecord(777,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::PropagationMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePropagationMatrix since it is agenda input to Ignore");

  }


  return MRecord(778,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to Ignore");

  }


  return MRecord(779,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::RadiationVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRadiationVector since it is agenda input to Ignore");

  }


  return MRecord(780,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Rational in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRational since it is agenda input to Ignore");

  }


  return MRecord(781,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::ScatteringMetaData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceScatteringMetaData since it is agenda input to Ignore");

  }


  return MRecord(782,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::SingleScatteringData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSingleScatteringData since it is agenda input to Ignore");

  }


  return MRecord(783,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Sparse in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSparse since it is agenda input to Ignore");

  }


  return MRecord(784,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::SpeciesAuxData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSpeciesAuxData since it is agenda input to Ignore");

  }


  return MRecord(785,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::StokesVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceStokesVector since it is agenda input to Ignore");

  }


  return MRecord(786,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::String in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceString since it is agenda input to Ignore");

  }


  return MRecord(787,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::TelsemAtlas in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTelsemAtlas since it is agenda input to Ignore");

  }


  return MRecord(788,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is agenda input to Ignore");

  }


  return MRecord(789,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is agenda input to Ignore");

  }


  return MRecord(790,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor5 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor5 since it is agenda input to Ignore");

  }


  return MRecord(791,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor6 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor6 since it is agenda input to Ignore");

  }


  return MRecord(792,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor7 since it is agenda input to Ignore");

  }


  return MRecord(793,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Timer in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTimer since it is agenda input to Ignore");

  }


  return MRecord(794,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Time in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTime since it is agenda input to Ignore");

  }


  return MRecord(795,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::TessemNN in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTessemNN since it is agenda input to Ignore");

  }


  return MRecord(796,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::TransmissionMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTransmissionMatrix since it is agenda input to Ignore");

  }


  return MRecord(797,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to Ignore");

  }


  return MRecord(798,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Ignore(

    [[maybe_unused]] Workspace& ws,

               const Var::Verbosity in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVerbosity since it is agenda input to Ignore");

  }


  return MRecord(799,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord INCLUDE(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(800,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexAdd(

    [[maybe_unused]] Workspace& ws,

                     Var::Index out,

               const Var::Index in,

               const Var::Index value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of IndexAdd");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceIndex since it is agenda input to IndexAdd");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceIndex since it is agenda input to IndexAdd");

  }


  return MRecord(801,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexNumberOfAtmosphericPoints(

    [[maybe_unused]] Workspace& ws,

                     Var::Index n) {

  if (n.islast()) {

    throw std::runtime_error("n needs to be a defined WorkspaceIndex since it is output of IndexNumberOfAtmosphericPoints");

  }


  return MRecord(802,

    Group::ArrayOfIndex({Group::Index(n.pos()), }),

    Group::ArrayOfIndex({35, 242, 139, 147, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSet(

    [[maybe_unused]] Workspace& ws,

                     Var::Index out,

               const Var::Index value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of IndexSet");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceIndex since it is agenda input to IndexSet");

  }


  return MRecord(803,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(value.pos()), }),

    TokVal{value.value()}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAbsorptionLines v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfAbsorptionLines since it is agenda input to IndexSetToLast");

  }


  return MRecord(804,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfAbsorptionLines v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is agenda input to IndexSetToLast");

  }


  return MRecord(805,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAgenda v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfAgenda since it is agenda input to IndexSetToLast");

  }


  return MRecord(806,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField1 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is agenda input to IndexSetToLast");

  }


  return MRecord(807,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField2 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is agenda input to IndexSetToLast");

  }


  return MRecord(808,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is agenda input to IndexSetToLast");

  }


  return MRecord(809,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfIndex v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfIndex since it is agenda input to IndexSetToLast");

  }


  return MRecord(810,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is agenda input to IndexSetToLast");

  }


  return MRecord(811,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPpath v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfPpath since it is agenda input to IndexSetToLast");

  }


  return MRecord(812,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfPropagationMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is agenda input to IndexSetToLast");

  }


  return MRecord(813,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfRadiationVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is agenda input to IndexSetToLast");

  }


  return MRecord(814,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfScatteringMetaData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is agenda input to IndexSetToLast");

  }


  return MRecord(815,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfSingleScatteringData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is agenda input to IndexSetToLast");

  }


  return MRecord(816,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfSpeciesTag v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is agenda input to IndexSetToLast");

  }


  return MRecord(817,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfStokesVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is agenda input to IndexSetToLast");

  }


  return MRecord(818,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfString v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfString since it is agenda input to IndexSetToLast");

  }


  return MRecord(819,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is agenda input to IndexSetToLast");

  }


  return MRecord(820,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor6 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is agenda input to IndexSetToLast");

  }


  return MRecord(821,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTime v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfTime since it is agenda input to IndexSetToLast");

  }


  return MRecord(822,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTransmissionMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is agenda input to IndexSetToLast");

  }


  return MRecord(823,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfVector since it is agenda input to IndexSetToLast");

  }


  return MRecord(824,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfCIARecord v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfCIARecord since it is agenda input to IndexSetToLast");

  }


  return MRecord(825,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField1 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfGriddedField1 since it is agenda input to IndexSetToLast");

  }


  return MRecord(826,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField2 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfGriddedField2 since it is agenda input to IndexSetToLast");

  }


  return MRecord(827,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to IndexSetToLast");

  }


  return MRecord(828,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField4 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfGriddedField4 since it is agenda input to IndexSetToLast");

  }


  return MRecord(829,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfIndex v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfIndex since it is agenda input to IndexSetToLast");

  }


  return MRecord(830,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to IndexSetToLast");

  }


  return MRecord(831,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPropagationMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfPropagationMatrix since it is agenda input to IndexSetToLast");

  }


  return MRecord(832,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to IndexSetToLast");

  }


  return MRecord(833,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRadiationVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfRadiationVector since it is agenda input to IndexSetToLast");

  }


  return MRecord(834,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRetrievalQuantity v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is agenda input to IndexSetToLast");

  }


  return MRecord(835,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfScatteringMetaData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfScatteringMetaData since it is agenda input to IndexSetToLast");

  }


  return MRecord(836,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfSingleScatteringData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfSingleScatteringData since it is agenda input to IndexSetToLast");

  }


  return MRecord(837,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfSparse v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfSparse since it is agenda input to IndexSetToLast");

  }


  return MRecord(838,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfStokesVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfStokesVector since it is agenda input to IndexSetToLast");

  }


  return MRecord(839,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfString v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfString since it is agenda input to IndexSetToLast");

  }


  return MRecord(840,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTelsemAtlas v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTelsemAtlas since it is agenda input to IndexSetToLast");

  }


  return MRecord(841,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor3 since it is agenda input to IndexSetToLast");

  }


  return MRecord(842,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor4 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor4 since it is agenda input to IndexSetToLast");

  }


  return MRecord(843,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor5 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor5 since it is agenda input to IndexSetToLast");

  }


  return MRecord(844,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor6 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor6 since it is agenda input to IndexSetToLast");

  }


  return MRecord(845,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor7 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor7 since it is agenda input to IndexSetToLast");

  }


  return MRecord(846,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTime v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTime since it is agenda input to IndexSetToLast");

  }


  return MRecord(847,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTransmissionMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is agenda input to IndexSetToLast");

  }


  return MRecord(848,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfVector since it is agenda input to IndexSetToLast");

  }


  return MRecord(849,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfXsecRecord v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfXsecRecord since it is agenda input to IndexSetToLast");

  }


  return MRecord(850,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexSetToLast(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceVector since it is agenda input to IndexSetToLast");

  }


  return MRecord(851,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexStepDown(

    [[maybe_unused]] Workspace& ws,

                     Var::Index out,

               const Var::Index in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of IndexStepDown");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceIndex since it is agenda input to IndexStepDown");

  }


  return MRecord(852,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord IndexStepUp(

    [[maybe_unused]] Workspace& ws,

                     Var::Index out,

               const Var::Index in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of IndexStepUp");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceIndex since it is agenda input to IndexStepUp");

  }


  return MRecord(853,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord InterpAtmFieldToPosition(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric out,

               const Var::Tensor3 field) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of InterpAtmFieldToPosition");

  } if (field.islast()) {

    throw std::runtime_error("field needs to be a defined WorkspaceTensor3 since it is agenda input to InterpAtmFieldToPosition");

  }


  return MRecord(854,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({35, 242, 139, 147, 381, 262, Group::Index(field.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord InterpGriddedField2ToPosition(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric out,

               const Var::GriddedField2 gfield2) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of InterpGriddedField2ToPosition");

  } if (gfield2.islast()) {

    throw std::runtime_error("gfield2 needs to be a defined WorkspaceGriddedField2 since it is agenda input to InterpGriddedField2ToPosition");

  }


  return MRecord(855,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({35, 139, 140, 148, 262, Group::Index(gfield2.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord InterpSurfaceFieldToPosition(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric out,

               const Var::Matrix field) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of InterpSurfaceFieldToPosition");

  } if (field.islast()) {

    throw std::runtime_error("field needs to be a defined WorkspaceMatrix since it is agenda input to InterpSurfaceFieldToPosition");

  }


  return MRecord(856,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({35, 139, 147, 262, 384, Group::Index(field.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord irradiance_fieldFromRadiance(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(857,

    Group::ArrayOfIndex({116, }),

    Group::ArrayOfIndex({245, 378, 0, 379, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord isotopologue_ratiosInitFromBuiltin(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(858,

    Group::ArrayOfIndex({117, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iyActiveSingleScat(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& trans_in_jacobian={},

               const Var::Numeric& pext_scaling={},

               const Var::Index& t_interp_order={}) {

  if (not trans_in_jacobian.isnull() and trans_in_jacobian.islast()) {

    throw std::runtime_error("trans_in_jacobian needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyActiveSingleScat");

  } if (not pext_scaling.isnull() and pext_scaling.islast()) {

    throw std::runtime_error("pext_scaling needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to iyActiveSingleScat");

  } if (not t_interp_order.isnull() and t_interp_order.islast()) {

    throw std::runtime_error("t_interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyActiveSingleScat");

  }


  static const auto trans_in_jacobian_default = Var::IndexCreate(ws, 0,

    "iyActiveSingleScat_trans_in_jacobian_autodefault",

    "auto generated variable with default from method definition");

  static const auto pext_scaling_default = Var::NumericCreate(ws, 1,

    "iyActiveSingleScat_pext_scaling_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_interp_order_default = Var::IndexCreate(ws, 1,

    "iyActiveSingleScat_t_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(859,

    Group::ArrayOfIndex({118, 121, 72, 228, 231, 227, 234, 235, 226, 229, 224, 232, }),

    Group::ArrayOfIndex({306, 104, 35, 242, 338, 339, 344, 21, 349, 351, 353, 149, 151, 153, 53, 52, 213, 75, 277, 267, 268, 122, 136, 137, 216, 238, 346, 132, 120, 131, 256, trans_in_jacobian.isnull() ? Index(trans_in_jacobian_default.pos()) : Group::Index(trans_in_jacobian.pos()), pext_scaling.isnull() ? Index(pext_scaling_default.pos()) : Group::Index(pext_scaling.pos()), t_interp_order.isnull() ? Index(t_interp_order_default.pos()) : Group::Index(t_interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iyActiveSingleScat2(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& trans_in_jacobian={},

               const Var::Numeric& pext_scaling={},

               const Var::Index& t_interp_order={}) {

  if (not trans_in_jacobian.isnull() and trans_in_jacobian.islast()) {

    throw std::runtime_error("trans_in_jacobian needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyActiveSingleScat2");

  } if (not pext_scaling.isnull() and pext_scaling.islast()) {

    throw std::runtime_error("pext_scaling needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to iyActiveSingleScat2");

  } if (not t_interp_order.isnull() and t_interp_order.islast()) {

    throw std::runtime_error("t_interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyActiveSingleScat2");

  }


  static const auto trans_in_jacobian_default = Var::IndexCreate(ws, 0,

    "iyActiveSingleScat2_trans_in_jacobian_autodefault",

    "auto generated variable with default from method definition");

  static const auto pext_scaling_default = Var::NumericCreate(ws, 1,

    "iyActiveSingleScat2_pext_scaling_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_interp_order_default = Var::IndexCreate(ws, 1,

    "iyActiveSingleScat2_t_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(860,

    Group::ArrayOfIndex({118, 121, 72, 228, 231, 227, 234, 235, 226, 229, 224, 232, }),

    Group::ArrayOfIndex({306, 104, 35, 242, 338, 339, 344, 21, 349, 351, 353, 149, 151, 153, 53, 52, 213, 75, 277, 267, 268, 122, 136, 137, 216, 238, 346, 132, 120, 131, 256, trans_in_jacobian.isnull() ? Index(trans_in_jacobian_default.pos()) : Group::Index(trans_in_jacobian.pos()), pext_scaling.isnull() ? Index(pext_scaling_default.pos()) : Group::Index(pext_scaling.pos()), t_interp_order.isnull() ? Index(t_interp_order_default.pos()) : Group::Index(t_interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iyApplyUnit(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(861,

    Group::ArrayOfIndex({118, 121, }),

    Group::ArrayOfIndex({306, 104, 122, 133, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iyCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(862,

    Group::ArrayOfIndex({118, 121, 216, }),

    Group::ArrayOfIndex({37, 36, 122, 125, 53, 48, 268, 104, 339, 258, 257, 259, 133, 127, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iyEmissionStandard(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(863,

    Group::ArrayOfIndex({118, 121, 72, 228, 231, 227, 234, 235, 226, 224, 225, 232, 233, }),

    Group::ArrayOfIndex({125, 306, 104, 35, 242, 338, 339, 344, 21, 349, 351, 353, 149, 151, 153, 53, 133, 122, 136, 137, 216, 259, 238, 346, 127, 128, 129, 123, 120, 131, 256, 315, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iyEmissionStandardSequential(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(864,

    Group::ArrayOfIndex({118, 121, 72, 228, 231, 227, 234, 235, 226, 224, 225, 232, 233, }),

    Group::ArrayOfIndex({125, 306, 104, 35, 242, 338, 339, 344, 21, 349, 351, 353, 149, 151, 153, 53, 133, 122, 136, 137, 216, 259, 238, 346, 127, 128, 129, 123, 120, 131, 256, 315, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iyHybrid(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& Naa_grid={},

               const Var::Index& t_interp_order={}) {

  if (not Naa_grid.isnull() and Naa_grid.islast()) {

    throw std::runtime_error("Naa_grid needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyHybrid");

  } if (not t_interp_order.isnull() and t_interp_order.islast()) {

    throw std::runtime_error("t_interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyHybrid");

  }


  static const auto Naa_grid_default = Var::IndexCreate(ws, 19,

    "iyHybrid_Naa_grid_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_interp_order_default = Var::IndexCreate(ws, 1,

    "iyHybrid_t_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(865,

    Group::ArrayOfIndex({118, 121, 72, 228, 231, 227, 234, 235, 226, 229, 224, 225, 232, }),

    Group::ArrayOfIndex({125, 306, 104, 35, 242, 338, 339, 344, 21, 349, 351, 353, 149, 151, 153, 53, 52, 213, 75, 277, 267, 133, 122, 136, 137, 238, 346, 127, 128, 129, 123, 120, 131, 216, 259, 256, 315, 49, 378, Naa_grid.isnull() ? Index(Naa_grid_default.pos()) : Group::Index(Naa_grid.pos()), t_interp_order.isnull() ? Index(t_interp_order_default.pos()) : Group::Index(t_interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iyHybrid2(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& Naa_grid={},

               const Var::Index& t_interp_order={}) {

  if (not Naa_grid.isnull() and Naa_grid.islast()) {

    throw std::runtime_error("Naa_grid needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyHybrid2");

  } if (not t_interp_order.isnull() and t_interp_order.islast()) {

    throw std::runtime_error("t_interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyHybrid2");

  }


  static const auto Naa_grid_default = Var::IndexCreate(ws, 19,

    "iyHybrid2_Naa_grid_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_interp_order_default = Var::IndexCreate(ws, 1,

    "iyHybrid2_t_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(866,

    Group::ArrayOfIndex({118, 121, 72, 228, 231, 227, 234, 235, 226, 229, 224, 225, 232, }),

    Group::ArrayOfIndex({125, 306, 104, 35, 242, 338, 339, 344, 21, 349, 351, 353, 149, 151, 153, 53, 52, 213, 75, 277, 267, 133, 122, 136, 137, 238, 346, 127, 128, 129, 123, 120, 131, 216, 259, 256, 315, 49, 378, Naa_grid.isnull() ? Index(Naa_grid_default.pos()) : Group::Index(Naa_grid.pos()), t_interp_order.isnull() ? Index(t_interp_order_default.pos()) : Group::Index(t_interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iyIndependentBeamApproximation(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& return_atm1d={},

               const Var::Index& skip_vmr={},

               const Var::Index& skip_pnd={},

               const Var::Index& return_masses={}) {

  if (not return_atm1d.isnull() and return_atm1d.islast()) {

    throw std::runtime_error("return_atm1d needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyIndependentBeamApproximation");

  } if (not skip_vmr.isnull() and skip_vmr.islast()) {

    throw std::runtime_error("skip_vmr needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyIndependentBeamApproximation");

  } if (not skip_pnd.isnull() and skip_pnd.islast()) {

    throw std::runtime_error("skip_pnd needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyIndependentBeamApproximation");

  } if (not return_masses.isnull() and return_masses.islast()) {

    throw std::runtime_error("return_masses needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyIndependentBeamApproximation");

  }


  static const auto return_atm1d_default = Var::IndexCreate(ws, 0,

    "iyIndependentBeamApproximation_return_atm1d_autodefault",

    "auto generated variable with default from method definition");

  static const auto skip_vmr_default = Var::IndexCreate(ws, 0,

    "iyIndependentBeamApproximation_skip_vmr_autodefault",

    "auto generated variable with default from method definition");

  static const auto skip_pnd_default = Var::IndexCreate(ws, 0,

    "iyIndependentBeamApproximation_skip_pnd_autodefault",

    "auto generated variable with default from method definition");

  static const auto return_masses_default = Var::IndexCreate(ws, 0,

    "iyIndependentBeamApproximation_return_masses_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(867,

    Group::ArrayOfIndex({118, 121, 216, 72, 38, }),

    Group::ArrayOfIndex({125, 104, 35, 242, 139, 147, 140, 148, 338, 381, 344, 339, 349, 351, 353, 149, 151, 153, 53, 52, 213, 199, 217, 220, 221, 120, 133, 131, 258, 257, 259, 136, 122, 124, return_atm1d.isnull() ? Index(return_atm1d_default.pos()) : Group::Index(return_atm1d.pos()), skip_vmr.isnull() ? Index(skip_vmr_default.pos()) : Group::Index(skip_vmr.pos()), skip_pnd.isnull() ? Index(skip_pnd_default.pos()) : Group::Index(skip_pnd.pos()), return_masses.isnull() ? Index(return_masses_default.pos()) : Group::Index(return_masses.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iyInterpCloudboxField(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& za_interp_order={},

               const Var::Index& za_restrict={},

               const Var::Index& cos_za_interp={},

               const Var::Numeric& za_extpolfac={},

               const Var::Index& aa_interp_order={}) {

  if (not za_interp_order.isnull() and za_interp_order.islast()) {

    throw std::runtime_error("za_interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyInterpCloudboxField");

  } if (not za_restrict.isnull() and za_restrict.islast()) {

    throw std::runtime_error("za_restrict needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyInterpCloudboxField");

  } if (not cos_za_interp.isnull() and cos_za_interp.islast()) {

    throw std::runtime_error("cos_za_interp needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyInterpCloudboxField");

  } if (not za_extpolfac.isnull() and za_extpolfac.islast()) {

    throw std::runtime_error("za_extpolfac needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to iyInterpCloudboxField");

  } if (not aa_interp_order.isnull() and aa_interp_order.islast()) {

    throw std::runtime_error("aa_interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyInterpCloudboxField");

  }


  static const auto za_interp_order_default = Var::IndexCreate(ws, 1,

    "iyInterpCloudboxField_za_interp_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto za_restrict_default = Var::IndexCreate(ws, 1,

    "iyInterpCloudboxField_za_restrict_autodefault",

    "auto generated variable with default from method definition");

  static const auto cos_za_interp_default = Var::IndexCreate(ws, 0,

    "iyInterpCloudboxField_cos_za_interp_autodefault",

    "auto generated variable with default from method definition");

  static const auto za_extpolfac_default = Var::NumericCreate(ws, 0.5,

    "iyInterpCloudboxField_za_extpolfac_autodefault",

    "auto generated variable with default from method definition");

  static const auto aa_interp_order_default = Var::IndexCreate(ws, 1,

    "iyInterpCloudboxField_aa_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(868,

    Group::ArrayOfIndex({118, }),

    Group::ArrayOfIndex({49, 262, 261, 136, 53, 52, 35, 242, 139, 147, 381, 384, 306, 378, 0, 104, za_interp_order.isnull() ? Index(za_interp_order_default.pos()) : Group::Index(za_interp_order.pos()), za_restrict.isnull() ? Index(za_restrict_default.pos()) : Group::Index(za_restrict.pos()), cos_za_interp.isnull() ? Index(cos_za_interp_default.pos()) : Group::Index(cos_za_interp.pos()), za_extpolfac.isnull() ? Index(za_extpolfac_default.pos()) : Group::Index(za_extpolfac.pos()), aa_interp_order.isnull() ? Index(aa_interp_order_default.pos()) : Group::Index(aa_interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iyLoopFrequencies(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(869,

    Group::ArrayOfIndex({118, 121, 216, 72, }),

    Group::ArrayOfIndex({122, 120, 131, 258, 257, 259, 306, 104, 126, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iyMC(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& t_interp_order={}) {

  if (not t_interp_order.isnull() and t_interp_order.islast()) {

    throw std::runtime_error("t_interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iyMC");

  }


  static const auto t_interp_order_default = Var::IndexCreate(ws, 1,

    "iyMC_t_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(870,

    Group::ArrayOfIndex({118, 121, 72, }),

    Group::ArrayOfIndex({120, 131, 258, 257, 122, 136, 35, 242, 139, 147, 381, 338, 344, 250, 384, 53, 52, 306, 104, 267, 128, 318, 238, 223, 220, 221, 213, 133, 169, 163, 161, 164, 171, t_interp_order.isnull() ? Index(t_interp_order_default.pos()) : Group::Index(t_interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iyReplaceFromAux(

    [[maybe_unused]] Workspace& ws,

               const Var::String aux_var) {

  if (aux_var.islast()) {

    throw std::runtime_error("aux_var needs to be a defined WorkspaceString since it is agenda input to iyReplaceFromAux");

  }


  return MRecord(871,

    Group::ArrayOfIndex({118, }),

    Group::ArrayOfIndex({121, 122, 136, Group::Index(aux_var.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iySurfaceCallAgendaX(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(872,

    Group::ArrayOfIndex({118, 72, }),

    Group::ArrayOfIndex({133, 131, 125, 53, 136, 104, 127, 262, 261, 259, 130, 325, 326, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iySurfaceFastem(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric wind_speed,

               const Var::Numeric& salinity={},

               const Var::Numeric& wind_direction={},

               const Var::Index& fastem_version={}) {

  if (not salinity.isnull() and salinity.islast()) {

    throw std::runtime_error("salinity needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to iySurfaceFastem");

  } if (wind_speed.islast()) {

    throw std::runtime_error("wind_speed needs to be a defined WorkspaceNumeric since it is agenda input to iySurfaceFastem");

  } if (not wind_direction.isnull() and wind_direction.islast()) {

    throw std::runtime_error("wind_direction needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to iySurfaceFastem");

  } if (not fastem_version.isnull() and fastem_version.islast()) {

    throw std::runtime_error("fastem_version needs to be a defined WorkspaceIndex (or left default) since it is agenda input to iySurfaceFastem");

  }


  static const auto salinity_default = Var::NumericCreate(ws, 0.035,

    "iySurfaceFastem_salinity_autodefault",

    "auto generated variable with default from method definition");

  static const auto wind_direction_default = Var::NumericCreate(ws, 0,

    "iySurfaceFastem_wind_direction_autodefault",

    "auto generated variable with default from method definition");

  static const auto fastem_version_default = Var::IndexCreate(ws, 6,

    "iySurfaceFastem_fastem_version_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(873,

    Group::ArrayOfIndex({118, 72, }),

    Group::ArrayOfIndex({131, 125, 136, 35, 339, 53, 306, 104, 262, 261, 259, 133, 127, 321, salinity.isnull() ? Index(salinity_default.pos()) : Group::Index(salinity.pos()), Group::Index(wind_speed.pos()), wind_direction.isnull() ? Index(wind_direction_default.pos()) : Group::Index(wind_direction.pos()), fastem_version.isnull() ? Index(fastem_version_default.pos()) : Group::Index(fastem_version.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iySurfaceRtpropAgenda(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(874,

    Group::ArrayOfIndex({118, 72, }),

    Group::ArrayOfIndex({131, 125, 136, 35, 339, 53, 306, 104, 262, 261, 259, 133, 127, 318, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iySurfaceRtpropCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(875,

    Group::ArrayOfIndex({118, 72, }),

    Group::ArrayOfIndex({313, 317, 312, 92, 93, 91, 131, 125, 136, 137, 35, 339, 53, 306, 104, 262, 261, 259, 133, 127, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iyTransmissionStandard(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(876,

    Group::ArrayOfIndex({118, 121, 72, 228, 231, 227, 234, 235, 226, 229, 224, 225, 232, }),

    Group::ArrayOfIndex({306, 104, 35, 242, 338, 339, 344, 21, 349, 351, 353, 149, 151, 153, 53, 52, 213, 75, 277, 267, 122, 136, 137, 216, 238, 346, 132, 120, 131, 256, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iy_transmitterMultiplePol(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(877,

    Group::ArrayOfIndex({118, }),

    Group::ArrayOfIndex({306, 104, 112, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord iy_transmitterSinglePol(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(878,

    Group::ArrayOfIndex({118, }),

    Group::ArrayOfIndex({306, 104, 112, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddAbsSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::Vector g3,

               const Var::String species,

               const Var::String& unit={},

               const Var::Index& for_species_tag={}) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddAbsSpecies");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddAbsSpecies");

  } if (g3.islast()) {

    throw std::runtime_error("g3 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddAbsSpecies");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to jacobianAddAbsSpecies");

  } if (not unit.isnull() and unit.islast()) {

    throw std::runtime_error("unit needs to be a defined WorkspaceString (or left default) since it is agenda input to jacobianAddAbsSpecies");

  } if (not for_species_tag.isnull() and for_species_tag.islast()) {

    throw std::runtime_error("for_species_tag needs to be a defined WorkspaceIndex (or left default) since it is agenda input to jacobianAddAbsSpecies");

  }


  static const auto unit_default = Var::StringCreate(ws, "vmr",

    "jacobianAddAbsSpecies_unit_autodefault",

    "auto generated variable with default from method definition");

  static const auto for_species_tag_default = Var::IndexCreate(ws, 1,

    "jacobianAddAbsSpecies_for_species_tag_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(879,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({35, 242, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(g3.pos()), Group::Index(species.pos()), unit.isnull() ? Index(unit_default.pos()) : Group::Index(unit.pos()), for_species_tag.isnull() ? Index(for_species_tag_default.pos()) : Group::Index(for_species_tag.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddBasicCatalogParameter(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier catalog_identity,

               const Var::String catalog_parameter) {

  if (catalog_identity.islast()) {

    throw std::runtime_error("catalog_identity needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to jacobianAddBasicCatalogParameter");

  } if (catalog_parameter.islast()) {

    throw std::runtime_error("catalog_parameter needs to be a defined WorkspaceString since it is agenda input to jacobianAddBasicCatalogParameter");

  }


  return MRecord(880,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({Group::Index(catalog_identity.pos()), Group::Index(catalog_parameter.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddBasicCatalogParameters(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier catalog_identities,

               const Var::ArrayOfString catalog_parameters) {

  if (catalog_identities.islast()) {

    throw std::runtime_error("catalog_identities needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to jacobianAddBasicCatalogParameters");

  } if (catalog_parameters.islast()) {

    throw std::runtime_error("catalog_parameters needs to be a defined WorkspaceArrayOfString since it is agenda input to jacobianAddBasicCatalogParameters");

  }


  return MRecord(881,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({Group::Index(catalog_identities.pos()), Group::Index(catalog_parameters.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddFreqShift(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& df={}) {

  if (not df.isnull() and df.islast()) {

    throw std::runtime_error("df needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to jacobianAddFreqShift");

  }


  static const auto df_default = Var::NumericCreate(ws, 100e3,

    "jacobianAddFreqShift_df_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(882,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({104, df.isnull() ? Index(df_default.pos()) : Group::Index(df.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddFreqStretch(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& df={}) {

  if (not df.isnull() and df.islast()) {

    throw std::runtime_error("df needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to jacobianAddFreqStretch");

  }


  static const auto df_default = Var::NumericCreate(ws, 100e3,

    "jacobianAddFreqStretch_df_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(883,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({104, df.isnull() ? Index(df_default.pos()) : Group::Index(df.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddShapeCatalogParameter(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier line_identity,

               const Var::String species,

               const Var::String variable,

               const Var::String coefficient) {

  if (line_identity.islast()) {

    throw std::runtime_error("line_identity needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to jacobianAddShapeCatalogParameter");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to jacobianAddShapeCatalogParameter");

  } if (variable.islast()) {

    throw std::runtime_error("variable needs to be a defined WorkspaceString since it is agenda input to jacobianAddShapeCatalogParameter");

  } if (coefficient.islast()) {

    throw std::runtime_error("coefficient needs to be a defined WorkspaceString since it is agenda input to jacobianAddShapeCatalogParameter");

  }


  return MRecord(884,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({Group::Index(line_identity.pos()), Group::Index(species.pos()), Group::Index(variable.pos()), Group::Index(coefficient.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddShapeCatalogParameters(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier line_identities,

               const Var::ArrayOfString species,

               const Var::ArrayOfString variables,

               const Var::ArrayOfString coefficients) {

  if (line_identities.islast()) {

    throw std::runtime_error("line_identities needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to jacobianAddShapeCatalogParameters");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceArrayOfString since it is agenda input to jacobianAddShapeCatalogParameters");

  } if (variables.islast()) {

    throw std::runtime_error("variables needs to be a defined WorkspaceArrayOfString since it is agenda input to jacobianAddShapeCatalogParameters");

  } if (coefficients.islast()) {

    throw std::runtime_error("coefficients needs to be a defined WorkspaceArrayOfString since it is agenda input to jacobianAddShapeCatalogParameters");

  }


  return MRecord(885,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({Group::Index(line_identities.pos()), Group::Index(species.pos()), Group::Index(variables.pos()), Group::Index(coefficients.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddMagField(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::Vector g3,

               const Var::String& component={},

               const Var::Numeric& dB={}) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddMagField");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddMagField");

  } if (g3.islast()) {

    throw std::runtime_error("g3 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddMagField");

  } if (not component.isnull() and component.islast()) {

    throw std::runtime_error("component needs to be a defined WorkspaceString (or left default) since it is agenda input to jacobianAddMagField");

  } if (not dB.isnull() and dB.islast()) {

    throw std::runtime_error("dB needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to jacobianAddMagField");

  }


  static const auto component_default = Var::StringCreate(ws, "v",

    "jacobianAddMagField_component_autodefault",

    "auto generated variable with default from method definition");

  static const auto dB_default = Var::NumericCreate(ws, 1.0e-7,

    "jacobianAddMagField_dB_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(886,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({35, 242, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(g3.pos()), component.isnull() ? Index(component_default.pos()) : Group::Index(component.pos()), dB.isnull() ? Index(dB_default.pos()) : Group::Index(dB.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddNLTE(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::Vector g3,

               const Var::QuantumIdentifier energy_level_identity,

               const Var::Numeric& dx={}) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddNLTE");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddNLTE");

  } if (g3.islast()) {

    throw std::runtime_error("g3 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddNLTE");

  } if (energy_level_identity.islast()) {

    throw std::runtime_error("energy_level_identity needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to jacobianAddNLTE");

  } if (not dx.isnull() and dx.islast()) {

    throw std::runtime_error("dx needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to jacobianAddNLTE");

  }


  static const auto dx_default = Var::NumericCreate(ws, 1.0e-3,

    "jacobianAddNLTE_dx_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(887,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({35, 242, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(g3.pos()), Group::Index(energy_level_identity.pos()), dx.isnull() ? Index(dx_default.pos()) : Group::Index(dx.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddNLTEs(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::Vector g3,

               const Var::ArrayOfQuantumIdentifier energy_level_identities,

               const Var::Numeric& dx={}) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddNLTEs");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddNLTEs");

  } if (g3.islast()) {

    throw std::runtime_error("g3 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddNLTEs");

  } if (energy_level_identities.islast()) {

    throw std::runtime_error("energy_level_identities needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to jacobianAddNLTEs");

  } if (not dx.isnull() and dx.islast()) {

    throw std::runtime_error("dx needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to jacobianAddNLTEs");

  }


  static const auto dx_default = Var::NumericCreate(ws, 1.0e-3,

    "jacobianAddNLTEs_dx_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(888,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({35, 242, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(g3.pos()), Group::Index(energy_level_identities.pos()), dx.isnull() ? Index(dx_default.pos()) : Group::Index(dx.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddPointingZa(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& poly_order={},

               const Var::String& calcmode={},

               const Var::Numeric& dza={}) {

  if (not poly_order.isnull() and poly_order.islast()) {

    throw std::runtime_error("poly_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to jacobianAddPointingZa");

  } if (not calcmode.isnull() and calcmode.islast()) {

    throw std::runtime_error("calcmode needs to be a defined WorkspaceString (or left default) since it is agenda input to jacobianAddPointingZa");

  } if (not dza.isnull() and dza.islast()) {

    throw std::runtime_error("dza needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to jacobianAddPointingZa");

  }


  static const auto poly_order_default = Var::IndexCreate(ws, 0,

    "jacobianAddPointingZa_poly_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto calcmode_default = Var::StringCreate(ws, "recalc",

    "jacobianAddPointingZa_calcmode_autodefault",

    "auto generated variable with default from method definition");

  static const auto dza_default = Var::NumericCreate(ws, 0.01,

    "jacobianAddPointingZa_dza_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(889,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({286, 296, poly_order.isnull() ? Index(poly_order_default.pos()) : Group::Index(poly_order.pos()), calcmode.isnull() ? Index(calcmode_default.pos()) : Group::Index(calcmode.pos()), dza.isnull() ? Index(dza_default.pos()) : Group::Index(dza.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddPolyfit(

    [[maybe_unused]] Workspace& ws,

               const Var::Index poly_order,

               const Var::Index& no_pol_variation={},

               const Var::Index& no_los_variation={},

               const Var::Index& no_mblock_variation={}) {

  if (poly_order.islast()) {

    throw std::runtime_error("poly_order needs to be a defined WorkspaceIndex since it is agenda input to jacobianAddPolyfit");

  } if (not no_pol_variation.isnull() and no_pol_variation.islast()) {

    throw std::runtime_error("no_pol_variation needs to be a defined WorkspaceIndex (or left default) since it is agenda input to jacobianAddPolyfit");

  } if (not no_los_variation.isnull() and no_los_variation.islast()) {

    throw std::runtime_error("no_los_variation needs to be a defined WorkspaceIndex (or left default) since it is agenda input to jacobianAddPolyfit");

  } if (not no_mblock_variation.isnull() and no_mblock_variation.islast()) {

    throw std::runtime_error("no_mblock_variation needs to be a defined WorkspaceIndex (or left default) since it is agenda input to jacobianAddPolyfit");

  }


  static const auto no_pol_variation_default = Var::IndexCreate(ws, 0,

    "jacobianAddPolyfit_no_pol_variation_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_los_variation_default = Var::IndexCreate(ws, 0,

    "jacobianAddPolyfit_no_los_variation_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_mblock_variation_default = Var::IndexCreate(ws, 0,

    "jacobianAddPolyfit_no_mblock_variation_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(890,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({295, 291, 286, Group::Index(poly_order.pos()), no_pol_variation.isnull() ? Index(no_pol_variation_default.pos()) : Group::Index(no_pol_variation.pos()), no_los_variation.isnull() ? Index(no_los_variation_default.pos()) : Group::Index(no_los_variation.pos()), no_mblock_variation.isnull() ? Index(no_mblock_variation_default.pos()) : Group::Index(no_mblock_variation.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddScatSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::Vector g3,

               const Var::String species,

               const Var::String quantity) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddScatSpecies");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddScatSpecies");

  } if (g3.islast()) {

    throw std::runtime_error("g3 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddScatSpecies");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to jacobianAddScatSpecies");

  } if (quantity.islast()) {

    throw std::runtime_error("quantity needs to be a defined WorkspaceString since it is agenda input to jacobianAddScatSpecies");

  }


  return MRecord(891,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({35, 242, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(g3.pos()), Group::Index(species.pos()), Group::Index(quantity.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddSinefit(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector period_lengths,

               const Var::Index& no_pol_variation={},

               const Var::Index& no_los_variation={},

               const Var::Index& no_mblock_variation={}) {

  if (period_lengths.islast()) {

    throw std::runtime_error("period_lengths needs to be a defined WorkspaceVector since it is agenda input to jacobianAddSinefit");

  } if (not no_pol_variation.isnull() and no_pol_variation.islast()) {

    throw std::runtime_error("no_pol_variation needs to be a defined WorkspaceIndex (or left default) since it is agenda input to jacobianAddSinefit");

  } if (not no_los_variation.isnull() and no_los_variation.islast()) {

    throw std::runtime_error("no_los_variation needs to be a defined WorkspaceIndex (or left default) since it is agenda input to jacobianAddSinefit");

  } if (not no_mblock_variation.isnull() and no_mblock_variation.islast()) {

    throw std::runtime_error("no_mblock_variation needs to be a defined WorkspaceIndex (or left default) since it is agenda input to jacobianAddSinefit");

  }


  static const auto no_pol_variation_default = Var::IndexCreate(ws, 0,

    "jacobianAddSinefit_no_pol_variation_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_los_variation_default = Var::IndexCreate(ws, 0,

    "jacobianAddSinefit_no_los_variation_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_mblock_variation_default = Var::IndexCreate(ws, 0,

    "jacobianAddSinefit_no_mblock_variation_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(892,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({295, 291, 286, Group::Index(period_lengths.pos()), no_pol_variation.isnull() ? Index(no_pol_variation_default.pos()) : Group::Index(no_pol_variation.pos()), no_los_variation.isnull() ? Index(no_los_variation_default.pos()) : Group::Index(no_los_variation.pos()), no_mblock_variation.isnull() ? Index(no_mblock_variation_default.pos()) : Group::Index(no_mblock_variation.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddSpecialSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::Vector g3,

               const Var::String species) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddSpecialSpecies");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddSpecialSpecies");

  } if (g3.islast()) {

    throw std::runtime_error("g3 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddSpecialSpecies");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to jacobianAddSpecialSpecies");

  }


  return MRecord(893,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({35, 242, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(g3.pos()), Group::Index(species.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddSurfaceQuantity(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::String quantity) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddSurfaceQuantity");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddSurfaceQuantity");

  } if (quantity.islast()) {

    throw std::runtime_error("quantity needs to be a defined WorkspaceString since it is agenda input to jacobianAddSurfaceQuantity");

  }


  return MRecord(894,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({35, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(quantity.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddTemperature(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::Vector g3,

               const Var::String& hse={}) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddTemperature");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddTemperature");

  } if (g3.islast()) {

    throw std::runtime_error("g3 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddTemperature");

  } if (not hse.isnull() and hse.islast()) {

    throw std::runtime_error("hse needs to be a defined WorkspaceString (or left default) since it is agenda input to jacobianAddTemperature");

  }


  static const auto hse_default = Var::StringCreate(ws, "on",

    "jacobianAddTemperature_hse_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(895,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({35, 242, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(g3.pos()), hse.isnull() ? Index(hse_default.pos()) : Group::Index(hse.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAddWind(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::Vector g3,

               const Var::String& component={},

               const Var::Numeric& dfrequency={}) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddWind");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddWind");

  } if (g3.islast()) {

    throw std::runtime_error("g3 needs to be a defined WorkspaceVector since it is agenda input to jacobianAddWind");

  } if (not component.isnull() and component.islast()) {

    throw std::runtime_error("component needs to be a defined WorkspaceString (or left default) since it is agenda input to jacobianAddWind");

  } if (not dfrequency.isnull() and dfrequency.islast()) {

    throw std::runtime_error("dfrequency needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to jacobianAddWind");

  }


  static const auto component_default = Var::StringCreate(ws, "v",

    "jacobianAddWind_component_autodefault",

    "auto generated variable with default from method definition");

  static const auto dfrequency_default = Var::NumericCreate(ws, 0.1,

    "jacobianAddWind_dfrequency_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(896,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({35, 242, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(g3.pos()), component.isnull() ? Index(component_default.pos()) : Group::Index(component.pos()), dfrequency.isnull() ? Index(dfrequency_default.pos()) : Group::Index(dfrequency.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianAdjustAndTransform(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(897,

    Group::ArrayOfIndex({134, }),

    Group::ArrayOfIndex({137, 358, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianCalcDoNothing(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(898,

    Group::ArrayOfIndex({134, }),

    Group::ArrayOfIndex({157, 119, 368, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianCalcFreqShift(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(899,

    Group::ArrayOfIndex({134, }),

    Group::ArrayOfIndex({157, 119, 368, 306, 104, 156, 287, 137, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianCalcFreqStretch(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(900,

    Group::ArrayOfIndex({134, }),

    Group::ArrayOfIndex({157, 119, 368, 306, 104, 156, 287, 295, 293, 291, 137, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianCalcPointingZaInterp(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(901,

    Group::ArrayOfIndex({134, }),

    Group::ArrayOfIndex({157, 119, 368, 306, 104, 283, 156, 287, 296, 137, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianCalcPointingZaRecalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(902,

    Group::ArrayOfIndex({134, }),

    Group::ArrayOfIndex({157, 119, 368, 35, 339, 53, 306, 104, 286, 283, 337, 156, 287, 296, 133, 127, 109, 137, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianCalcPolyfit(

    [[maybe_unused]] Workspace& ws,

               const Var::Index poly_coeff) {

  if (poly_coeff.islast()) {

    throw std::runtime_error("poly_coeff needs to be a defined WorkspaceIndex since it is agenda input to jacobianCalcPolyfit");

  }


  return MRecord(903,

    Group::ArrayOfIndex({134, }),

    Group::ArrayOfIndex({157, 119, 368, 287, 295, 293, 291, 137, Group::Index(poly_coeff.pos()), }),

    TokVal{poly_coeff.value()}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianCalcSinefit(

    [[maybe_unused]] Workspace& ws,

               const Var::Index period_index) {

  if (period_index.islast()) {

    throw std::runtime_error("period_index needs to be a defined WorkspaceIndex since it is agenda input to jacobianCalcSinefit");

  }


  return MRecord(904,

    Group::ArrayOfIndex({134, }),

    Group::ArrayOfIndex({157, 119, 368, 287, 295, 293, 291, 137, Group::Index(period_index.pos()), }),

    TokVal{period_index.value()}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianClose(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(905,

    Group::ArrayOfIndex({136, 135, }),

    Group::ArrayOfIndex({137, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianFromTwoY(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector y_pert,

               const Var::Numeric pert_size) {

  if (y_pert.islast()) {

    throw std::runtime_error("y_pert needs to be a defined WorkspaceVector since it is agenda input to jacobianFromTwoY");

  } if (pert_size.islast()) {

    throw std::runtime_error("pert_size needs to be a defined WorkspaceNumeric since it is agenda input to jacobianFromTwoY");

  }


  return MRecord(906,

    Group::ArrayOfIndex({134, }),

    Group::ArrayOfIndex({360, Group::Index(y_pert.pos()), Group::Index(pert_size.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianFromYbatch(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric pert_size) {

  if (pert_size.islast()) {

    throw std::runtime_error("pert_size needs to be a defined WorkspaceNumeric since it is agenda input to jacobianFromYbatch");

  }


  return MRecord(907,

    Group::ArrayOfIndex({134, }),

    Group::ArrayOfIndex({369, 360, Group::Index(pert_size.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianInit(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(908,

    Group::ArrayOfIndex({137, 135, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianOff(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(909,

    Group::ArrayOfIndex({136, 135, 137, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianSetAffineTransformation(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix transformation_matrix,

               const Var::Vector offset_vector) {

  if (transformation_matrix.islast()) {

    throw std::runtime_error("transformation_matrix needs to be a defined WorkspaceMatrix since it is agenda input to jacobianSetAffineTransformation");

  } if (offset_vector.islast()) {

    throw std::runtime_error("offset_vector needs to be a defined WorkspaceVector since it is agenda input to jacobianSetAffineTransformation");

  }


  return MRecord(910,

    Group::ArrayOfIndex({137, }),

    Group::ArrayOfIndex({Group::Index(transformation_matrix.pos()), Group::Index(offset_vector.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord jacobianSetFuncTransformation(

    [[maybe_unused]] Workspace& ws,

               const Var::String transformation_func,

               const Var::Numeric& z_min={},

               const Var::Numeric& z_max={}) {

  if (transformation_func.islast()) {

    throw std::runtime_error("transformation_func needs to be a defined WorkspaceString since it is agenda input to jacobianSetFuncTransformation");

  } if (not z_min.isnull() and z_min.islast()) {

    throw std::runtime_error("z_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to jacobianSetFuncTransformation");

  } if (not z_max.isnull() and z_max.islast()) {

    throw std::runtime_error("z_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to jacobianSetFuncTransformation");

  }


  static const auto z_min_default = Var::NumericCreate(ws, 0,

    "jacobianSetFuncTransformation_z_min_autodefault",

    "auto generated variable with default from method definition");

  static const auto z_max_default = Var::NumericCreate(ws, -99e99,

    "jacobianSetFuncTransformation_z_max_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(911,

    Group::ArrayOfIndex({137, }),

    Group::ArrayOfIndex({Group::Index(transformation_func.pos()), z_min.isnull() ? Index(z_min_default.pos()) : Group::Index(z_min.pos()), z_max.isnull() ? Index(z_max_default.pos()) : Group::Index(z_max.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord lat_gridFromRawField(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField3 field_raw) {

  if (field_raw.islast()) {

    throw std::runtime_error("field_raw needs to be a defined WorkspaceGriddedField3 since it is agenda input to lat_gridFromRawField");

  }


  return MRecord(912,

    Group::ArrayOfIndex({139, }),

    Group::ArrayOfIndex({Group::Index(field_raw.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord lbl_checkedCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(913,

    Group::ArrayOfIndex({141, }),

    Group::ArrayOfIndex({11, 21, 117, 200, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord LocalTimeOffset(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric dt) {

  if (dt.islast()) {

    throw std::runtime_error("dt needs to be a defined WorkspaceNumeric since it is output of LocalTimeOffset");

  }


  return MRecord(914,

    Group::ArrayOfIndex({Group::Index(dt.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord lon_gridFromRawField(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField3 field_raw) {

  if (field_raw.islast()) {

    throw std::runtime_error("field_raw needs to be a defined WorkspaceGriddedField3 since it is agenda input to lon_gridFromRawField");

  }


  return MRecord(915,

    Group::ArrayOfIndex({147, }),

    Group::ArrayOfIndex({Group::Index(field_raw.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MagFieldsCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& interp_order={}) {

  if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to MagFieldsCalc");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "MagFieldsCalc_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(916,

    Group::ArrayOfIndex({149, 151, 153, }),

    Group::ArrayOfIndex({242, 139, 147, 150, 152, 154, 35, interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MagFieldsCalcExpand1D(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& interp_order={}) {

  if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to MagFieldsCalcExpand1D");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "MagFieldsCalcExpand1D_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(917,

    Group::ArrayOfIndex({149, 151, 153, }),

    Group::ArrayOfIndex({242, 139, 147, 150, 152, 154, 35, interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MagFieldsFromAltitudeRawCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& interp_order={},

               const Var::Numeric& extrapolating={}) {

  if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to MagFieldsFromAltitudeRawCalc");

  } if (not extrapolating.isnull() and extrapolating.islast()) {

    throw std::runtime_error("extrapolating needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to MagFieldsFromAltitudeRawCalc");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "MagFieldsFromAltitudeRawCalc_interp_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto extrapolating_default = Var::NumericCreate(ws, 1e99,

    "MagFieldsFromAltitudeRawCalc_extrapolating_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(918,

    Group::ArrayOfIndex({149, 151, 153, }),

    Group::ArrayOfIndex({139, 147, 381, 150, 152, 154, interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), extrapolating.isnull() ? Index(extrapolating_default.pos()) : Group::Index(extrapolating.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MagRawRead(

    [[maybe_unused]] Workspace& ws,

               const Var::String basename) {

  if (basename.islast()) {

    throw std::runtime_error("basename needs to be a defined WorkspaceString since it is agenda input to MagRawRead");

  }


  return MRecord(919,

    Group::ArrayOfIndex({150, 152, 154, }),

    Group::ArrayOfIndex({Group::Index(basename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MatrixAddScalar(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Matrix in,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixAddScalar");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is agenda input to MatrixAddScalar");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to MatrixAddScalar");

  }


  return MRecord(920,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MatrixCBR(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Vector f) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixCBR");

  } if (f.islast()) {

    throw std::runtime_error("f needs to be a defined WorkspaceVector since it is agenda input to MatrixCBR");

  }


  return MRecord(921,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({306, Group::Index(f.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MatrixCopySparse(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Sparse in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixCopySparse");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSparse since it is agenda input to MatrixCopySparse");

  }


  return MRecord(922,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MatrixExtractFromTensor3(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Tensor3 in,

               const Var::Index i,

               const Var::String direction) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixExtractFromTensor3");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is agenda input to MatrixExtractFromTensor3");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceIndex since it is agenda input to MatrixExtractFromTensor3");

  } if (direction.islast()) {

    throw std::runtime_error("direction needs to be a defined WorkspaceString since it is agenda input to MatrixExtractFromTensor3");

  }


  return MRecord(923,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(i.pos()), Group::Index(direction.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MatrixFromCovarianceMatrix(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::CovarianceMatrix in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixFromCovarianceMatrix");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCovarianceMatrix since it is agenda input to MatrixFromCovarianceMatrix");

  }


  return MRecord(924,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MatrixIdentity(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Index n,

               const Var::Numeric& value={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixIdentity");

  } if (n.islast()) {

    throw std::runtime_error("n needs to be a defined WorkspaceIndex since it is agenda input to MatrixIdentity");

  } if (not value.isnull() and value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to MatrixIdentity");

  }


  static const auto value_default = Var::NumericCreate(ws, 1,

    "MatrixIdentity_value_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(925,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(n.pos()), value.isnull() ? Index(value_default.pos()) : Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MatrixMatrixMultiply(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Matrix m,

               const Var::Matrix x) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixMatrixMultiply");

  } if (m.islast()) {

    throw std::runtime_error("m needs to be a defined WorkspaceMatrix since it is agenda input to MatrixMatrixMultiply");

  } if (x.islast()) {

    throw std::runtime_error("x needs to be a defined WorkspaceMatrix since it is agenda input to MatrixMatrixMultiply");

  }


  return MRecord(926,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(m.pos()), Group::Index(x.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MatrixPlanck(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Vector f,

               const Var::Numeric t) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixPlanck");

  } if (f.islast()) {

    throw std::runtime_error("f needs to be a defined WorkspaceVector since it is agenda input to MatrixPlanck");

  } if (t.islast()) {

    throw std::runtime_error("t needs to be a defined WorkspaceNumeric since it is agenda input to MatrixPlanck");

  }


  return MRecord(927,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({306, Group::Index(f.pos()), Group::Index(t.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MatrixScale(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Matrix in,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixScale");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is agenda input to MatrixScale");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to MatrixScale");

  }


  return MRecord(928,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MatrixSet(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Matrix value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixSet");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceMatrix since it is agenda input to MatrixSet");

  }


  return MRecord(929,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(value.pos()), }),

    TokVal{value.value()}, Agenda{});

}


[[nodiscard]] inline

MRecord MatrixSetConstant(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixSetConstant");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to MatrixSetConstant");

  }


  return MRecord(930,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({185, 184, Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MatrixUnitIntensity(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Vector f) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of MatrixUnitIntensity");

  } if (f.islast()) {

    throw std::runtime_error("f needs to be a defined WorkspaceVector since it is agenda input to MatrixUnitIntensity");

  }


  return MRecord(931,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({306, Group::Index(f.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MatrixVectorMultiply(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Matrix m,

               const Var::Vector v) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of MatrixVectorMultiply");

  } if (m.islast()) {

    throw std::runtime_error("m needs to be a defined WorkspaceMatrix since it is agenda input to MatrixVectorMultiply");

  } if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceVector since it is agenda input to MatrixVectorMultiply");

  }


  return MRecord(932,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(m.pos()), Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Matrix1ColFromVector(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Vector v) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Matrix1ColFromVector");

  } if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceVector since it is agenda input to Matrix1ColFromVector");

  }


  return MRecord(933,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Matrix2ColFromVectors(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Vector v1,

               const Var::Vector v2) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Matrix2ColFromVectors");

  } if (v1.islast()) {

    throw std::runtime_error("v1 needs to be a defined WorkspaceVector since it is agenda input to Matrix2ColFromVectors");

  } if (v2.islast()) {

    throw std::runtime_error("v2 needs to be a defined WorkspaceVector since it is agenda input to Matrix2ColFromVectors");

  }


  return MRecord(934,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(v1.pos()), Group::Index(v2.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Matrix3ColFromVectors(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Vector v1,

               const Var::Vector v2,

               const Var::Vector v3) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Matrix3ColFromVectors");

  } if (v1.islast()) {

    throw std::runtime_error("v1 needs to be a defined WorkspaceVector since it is agenda input to Matrix3ColFromVectors");

  } if (v2.islast()) {

    throw std::runtime_error("v2 needs to be a defined WorkspaceVector since it is agenda input to Matrix3ColFromVectors");

  } if (v3.islast()) {

    throw std::runtime_error("v3 needs to be a defined WorkspaceVector since it is agenda input to Matrix3ColFromVectors");

  }


  return MRecord(935,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(v1.pos()), Group::Index(v2.pos()), Group::Index(v3.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Matrix1RowFromVector(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Vector v) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Matrix1RowFromVector");

  } if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceVector since it is agenda input to Matrix1RowFromVector");

  }


  return MRecord(936,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Matrix2RowFromVectors(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Vector v1,

               const Var::Vector v2) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Matrix2RowFromVectors");

  } if (v1.islast()) {

    throw std::runtime_error("v1 needs to be a defined WorkspaceVector since it is agenda input to Matrix2RowFromVectors");

  } if (v2.islast()) {

    throw std::runtime_error("v2 needs to be a defined WorkspaceVector since it is agenda input to Matrix2RowFromVectors");

  }


  return MRecord(937,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(v1.pos()), Group::Index(v2.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Matrix3RowFromVectors(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::Vector v1,

               const Var::Vector v2,

               const Var::Vector v3) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of Matrix3RowFromVectors");

  } if (v1.islast()) {

    throw std::runtime_error("v1 needs to be a defined WorkspaceVector since it is agenda input to Matrix3RowFromVectors");

  } if (v2.islast()) {

    throw std::runtime_error("v2 needs to be a defined WorkspaceVector since it is agenda input to Matrix3RowFromVectors");

  } if (v3.islast()) {

    throw std::runtime_error("v3 needs to be a defined WorkspaceVector since it is agenda input to Matrix3RowFromVectors");

  }


  return MRecord(938,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(v1.pos()), Group::Index(v2.pos()), Group::Index(v3.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord mblock_dlos_gridUniformCircular(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric spacing,

               const Var::Numeric width,

               const Var::Index& centre={}) {

  if (spacing.islast()) {

    throw std::runtime_error("spacing needs to be a defined WorkspaceNumeric since it is agenda input to mblock_dlos_gridUniformCircular");

  } if (width.islast()) {

    throw std::runtime_error("width needs to be a defined WorkspaceNumeric since it is agenda input to mblock_dlos_gridUniformCircular");

  } if (not centre.isnull() and centre.islast()) {

    throw std::runtime_error("centre needs to be a defined WorkspaceIndex (or left default) since it is agenda input to mblock_dlos_gridUniformCircular");

  }


  static const auto centre_default = Var::IndexCreate(ws, 0,

    "mblock_dlos_gridUniformCircular_centre_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(939,

    Group::ArrayOfIndex({156, }),

    Group::ArrayOfIndex({Group::Index(spacing.pos()), Group::Index(width.pos()), centre.isnull() ? Index(centre_default.pos()) : Group::Index(centre.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord mblock_dlos_gridUniformRectangular(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric spacing,

               const Var::Numeric za_width,

               const Var::Numeric aa_width,

               const Var::Index& centre={}) {

  if (spacing.islast()) {

    throw std::runtime_error("spacing needs to be a defined WorkspaceNumeric since it is agenda input to mblock_dlos_gridUniformRectangular");

  } if (za_width.islast()) {

    throw std::runtime_error("za_width needs to be a defined WorkspaceNumeric since it is agenda input to mblock_dlos_gridUniformRectangular");

  } if (aa_width.islast()) {

    throw std::runtime_error("aa_width needs to be a defined WorkspaceNumeric since it is agenda input to mblock_dlos_gridUniformRectangular");

  } if (not centre.isnull() and centre.islast()) {

    throw std::runtime_error("centre needs to be a defined WorkspaceIndex (or left default) since it is agenda input to mblock_dlos_gridUniformRectangular");

  }


  static const auto centre_default = Var::IndexCreate(ws, 0,

    "mblock_dlos_gridUniformRectangular_centre_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(940,

    Group::ArrayOfIndex({156, }),

    Group::ArrayOfIndex({Group::Index(spacing.pos()), Group::Index(za_width.pos()), Group::Index(aa_width.pos()), centre.isnull() ? Index(centre_default.pos()) : Group::Index(centre.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord mc_antennaSetGaussian(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric za_sigma,

               const Var::Numeric aa_sigma) {

  if (za_sigma.islast()) {

    throw std::runtime_error("za_sigma needs to be a defined WorkspaceNumeric since it is agenda input to mc_antennaSetGaussian");

  } if (aa_sigma.islast()) {

    throw std::runtime_error("aa_sigma needs to be a defined WorkspaceNumeric since it is agenda input to mc_antennaSetGaussian");

  }


  return MRecord(941,

    Group::ArrayOfIndex({158, }),

    Group::ArrayOfIndex({Group::Index(za_sigma.pos()), Group::Index(aa_sigma.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord mc_antennaSetGaussianByFWHM(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric za_fwhm,

               const Var::Numeric aa_fwhm) {

  if (za_fwhm.islast()) {

    throw std::runtime_error("za_fwhm needs to be a defined WorkspaceNumeric since it is agenda input to mc_antennaSetGaussianByFWHM");

  } if (aa_fwhm.islast()) {

    throw std::runtime_error("aa_fwhm needs to be a defined WorkspaceNumeric since it is agenda input to mc_antennaSetGaussianByFWHM");

  }


  return MRecord(942,

    Group::ArrayOfIndex({158, }),

    Group::ArrayOfIndex({Group::Index(za_fwhm.pos()), Group::Index(aa_fwhm.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord mc_antennaSetPencilBeam(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(943,

    Group::ArrayOfIndex({158, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MCGeneral(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& l_mc_scat_order={},

               const Var::Index& t_interp_order={}) {

  if (not l_mc_scat_order.isnull() and l_mc_scat_order.islast()) {

    throw std::runtime_error("l_mc_scat_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to MCGeneral");

  } if (not t_interp_order.isnull() and t_interp_order.islast()) {

    throw std::runtime_error("t_interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to MCGeneral");

  }


  static const auto l_mc_scat_order_default = Var::IndexCreate(ws, 11,

    "MCGeneral_l_mc_scat_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_interp_order_default = Var::IndexCreate(ws, 1,

    "MCGeneral_t_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(944,

    Group::ArrayOfIndex({360, 160, 159, 165, 167, 166, }),

    Group::ArrayOfIndex({158, 104, 105, 286, 283, 306, 35, 223, 220, 221, 128, 318, 238, 242, 139, 147, 381, 250, 384, 338, 344, 53, 52, 213, 267, 36, 37, 268, 48, 133, 168, 169, 163, 161, 164, 171, l_mc_scat_order.isnull() ? Index(l_mc_scat_order_default.pos()) : Group::Index(l_mc_scat_order.pos()), t_interp_order.isnull() ? Index(t_interp_order_default.pos()) : Group::Index(t_interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MCRadar(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& ze_tref={},

               const Var::Numeric& k2={},

               const Var::Index& t_interp_order={}) {

  if (not ze_tref.isnull() and ze_tref.islast()) {

    throw std::runtime_error("ze_tref needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to MCRadar");

  } if (not k2.isnull() and k2.islast()) {

    throw std::runtime_error("k2 needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to MCRadar");

  } if (not t_interp_order.isnull() and t_interp_order.islast()) {

    throw std::runtime_error("t_interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to MCRadar");

  }


  static const auto ze_tref_default = Var::NumericCreate(ws, 273.15,

    "MCRadar_ze_tref_autodefault",

    "auto generated variable with default from method definition");

  static const auto k2_default = Var::NumericCreate(ws, -1,

    "MCRadar_k2_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_interp_order_default = Var::IndexCreate(ws, 1,

    "MCRadar_t_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(945,

    Group::ArrayOfIndex({360, 159, }),

    Group::ArrayOfIndex({158, 104, 105, 286, 283, 306, 35, 220, 223, 221, 238, 242, 139, 147, 381, 250, 384, 338, 344, 53, 52, 213, 267, 170, 246, 36, 37, 268, 48, 133, 162, 168, 161, ze_tref.isnull() ? Index(ze_tref_default.pos()) : Group::Index(ze_tref.pos()), k2.isnull() ? Index(k2_default.pos()) : Group::Index(k2.pos()), t_interp_order.isnull() ? Index(t_interp_order_default.pos()) : Group::Index(t_interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord MCSetSeedFromTime(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(946,

    Group::ArrayOfIndex({168, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nlte_fieldRescalePopulationLevels(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric s) {

  if (s.islast()) {

    throw std::runtime_error("s needs to be a defined WorkspaceNumeric since it is agenda input to nlte_fieldRescalePopulationLevels");

  }


  return MRecord(947,

    Group::ArrayOfIndex({339, }),

    Group::ArrayOfIndex({Group::Index(s.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nlte_fieldForSingleSpeciesNonOverlappingLines(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric df,

               const Var::Index nz,

               const Var::Index nf,

               const Var::Index dampened,

               const Var::Numeric& convergence_limit={},

               const Var::Index& iteration_limit={}) {

  if (df.islast()) {

    throw std::runtime_error("df needs to be a defined WorkspaceNumeric since it is agenda input to nlte_fieldForSingleSpeciesNonOverlappingLines");

  } if (not convergence_limit.isnull() and convergence_limit.islast()) {

    throw std::runtime_error("convergence_limit needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to nlte_fieldForSingleSpeciesNonOverlappingLines");

  } if (nz.islast()) {

    throw std::runtime_error("nz needs to be a defined WorkspaceIndex since it is agenda input to nlte_fieldForSingleSpeciesNonOverlappingLines");

  } if (nf.islast()) {

    throw std::runtime_error("nf needs to be a defined WorkspaceIndex since it is agenda input to nlte_fieldForSingleSpeciesNonOverlappingLines");

  } if (dampened.islast()) {

    throw std::runtime_error("dampened needs to be a defined WorkspaceIndex since it is agenda input to nlte_fieldForSingleSpeciesNonOverlappingLines");

  } if (not iteration_limit.isnull() and iteration_limit.islast()) {

    throw std::runtime_error("iteration_limit needs to be a defined WorkspaceIndex (or left default) since it is agenda input to nlte_fieldForSingleSpeciesNonOverlappingLines");

  }


  static const auto convergence_limit_default = Var::NumericCreate(ws, 1e-6,

    "nlte_fieldForSingleSpeciesNonOverlappingLines_convergence_limit_autodefault",

    "auto generated variable with default from method definition");

  static const auto iteration_limit_default = Var::IndexCreate(ws, 20,

    "nlte_fieldForSingleSpeciesNonOverlappingLines_iteration_limit_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(948,

    Group::ArrayOfIndex({339, }),

    Group::ArrayOfIndex({21, 11, 182, 181, 117, 127, 217, 128, 129, 123, 238, 346, 344, 338, 381, 242, 35, 250, 315, 191, Group::Index(df.pos()), convergence_limit.isnull() ? Index(convergence_limit_default.pos()) : Group::Index(convergence_limit.pos()), Group::Index(nz.pos()), Group::Index(nf.pos()), Group::Index(dampened.pos()), iteration_limit.isnull() ? Index(iteration_limit_default.pos()) : Group::Index(iteration_limit.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord collision_coefficientsFromSplitFiles(

    [[maybe_unused]] Workspace& ws,

               const Var::String& basename={}) {

  if (not basename.isnull() and basename.islast()) {

    throw std::runtime_error("basename needs to be a defined WorkspaceString (or left default) since it is agenda input to collision_coefficientsFromSplitFiles");

  }


  static const auto basename_default = Var::StringCreate(ws, "./",

    "collision_coefficientsFromSplitFiles_basename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(949,

    Group::ArrayOfIndex({182, 181, }),

    Group::ArrayOfIndex({21, basename.isnull() ? Index(basename_default.pos()) : Group::Index(basename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord NumericAdd(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric out,

               const Var::Numeric in,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of NumericAdd");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceNumeric since it is agenda input to NumericAdd");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to NumericAdd");

  }


  return MRecord(950,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord NumericFromVector(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric out,

               const Var::Vector in,

               const Var::String op) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of NumericFromVector");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to NumericFromVector");

  } if (op.islast()) {

    throw std::runtime_error("op needs to be a defined WorkspaceString since it is agenda input to NumericFromVector");

  }


  return MRecord(951,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(op.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord NumericInvScale(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric out,

               const Var::Numeric in,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of NumericInvScale");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceNumeric since it is agenda input to NumericInvScale");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to NumericInvScale");

  }


  return MRecord(952,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord NumericScale(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric out,

               const Var::Numeric in,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of NumericScale");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceNumeric since it is agenda input to NumericScale");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to NumericScale");

  }


  return MRecord(953,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord NumericSet(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric out,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of NumericSet");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to NumericSet");

  }


  return MRecord(954,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(value.pos()), }),

    TokVal{value.value()}, Agenda{});

}


[[nodiscard]] inline

MRecord QuantumIdentifierSet(

    [[maybe_unused]] Workspace& ws,

                     Var::QuantumIdentifier out,

               const Var::String string_initializer) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceQuantumIdentifier since it is output of QuantumIdentifierSet");

  } if (string_initializer.islast()) {

    throw std::runtime_error("string_initializer needs to be a defined WorkspaceString since it is agenda input to QuantumIdentifierSet");

  }


  return MRecord(955,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(string_initializer.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ArrayOfQuantumIdentifierSet(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfQuantumIdentifier out,

               const Var::ArrayOfString string_initializers) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of ArrayOfQuantumIdentifierSet");

  } if (string_initializers.islast()) {

    throw std::runtime_error("string_initializers needs to be a defined WorkspaceArrayOfString since it is agenda input to ArrayOfQuantumIdentifierSet");

  }


  return MRecord(956,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(string_initializers.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAbsorptionLines v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfAbsorptionLines since it is agenda input to nelemGet");

  }


  return MRecord(957,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfAbsorptionLines v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is agenda input to nelemGet");

  }


  return MRecord(958,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAgenda v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfAgenda since it is agenda input to nelemGet");

  }


  return MRecord(959,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField1 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is agenda input to nelemGet");

  }


  return MRecord(960,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField2 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is agenda input to nelemGet");

  }


  return MRecord(961,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is agenda input to nelemGet");

  }


  return MRecord(962,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfIndex v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfIndex since it is agenda input to nelemGet");

  }


  return MRecord(963,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is agenda input to nelemGet");

  }


  return MRecord(964,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPpath v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfPpath since it is agenda input to nelemGet");

  }


  return MRecord(965,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfPropagationMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is agenda input to nelemGet");

  }


  return MRecord(966,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfRadiationVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is agenda input to nelemGet");

  }


  return MRecord(967,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfScatteringMetaData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is agenda input to nelemGet");

  }


  return MRecord(968,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfSingleScatteringData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is agenda input to nelemGet");

  }


  return MRecord(969,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfSpeciesTag v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is agenda input to nelemGet");

  }


  return MRecord(970,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfStokesVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is agenda input to nelemGet");

  }


  return MRecord(971,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfString v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfString since it is agenda input to nelemGet");

  }


  return MRecord(972,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is agenda input to nelemGet");

  }


  return MRecord(973,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor6 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is agenda input to nelemGet");

  }


  return MRecord(974,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTime v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfTime since it is agenda input to nelemGet");

  }


  return MRecord(975,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTransmissionMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is agenda input to nelemGet");

  }


  return MRecord(976,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfArrayOfVector since it is agenda input to nelemGet");

  }


  return MRecord(977,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfCIARecord v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfCIARecord since it is agenda input to nelemGet");

  }


  return MRecord(978,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField1 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfGriddedField1 since it is agenda input to nelemGet");

  }


  return MRecord(979,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField2 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfGriddedField2 since it is agenda input to nelemGet");

  }


  return MRecord(980,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to nelemGet");

  }


  return MRecord(981,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField4 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfGriddedField4 since it is agenda input to nelemGet");

  }


  return MRecord(982,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfIndex v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfIndex since it is agenda input to nelemGet");

  }


  return MRecord(983,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to nelemGet");

  }


  return MRecord(984,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPropagationMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfPropagationMatrix since it is agenda input to nelemGet");

  }


  return MRecord(985,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to nelemGet");

  }


  return MRecord(986,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRadiationVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfRadiationVector since it is agenda input to nelemGet");

  }


  return MRecord(987,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRetrievalQuantity v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is agenda input to nelemGet");

  }


  return MRecord(988,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfScatteringMetaData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfScatteringMetaData since it is agenda input to nelemGet");

  }


  return MRecord(989,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfSingleScatteringData v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfSingleScatteringData since it is agenda input to nelemGet");

  }


  return MRecord(990,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfSparse v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfSparse since it is agenda input to nelemGet");

  }


  return MRecord(991,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfStokesVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfStokesVector since it is agenda input to nelemGet");

  }


  return MRecord(992,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfString v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfString since it is agenda input to nelemGet");

  }


  return MRecord(993,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTelsemAtlas v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTelsemAtlas since it is agenda input to nelemGet");

  }


  return MRecord(994,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor3 since it is agenda input to nelemGet");

  }


  return MRecord(995,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor4 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor4 since it is agenda input to nelemGet");

  }


  return MRecord(996,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor5 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor5 since it is agenda input to nelemGet");

  }


  return MRecord(997,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor6 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor6 since it is agenda input to nelemGet");

  }


  return MRecord(998,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor7 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTensor7 since it is agenda input to nelemGet");

  }


  return MRecord(999,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTime v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTime since it is agenda input to nelemGet");

  }


  return MRecord(1000,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTransmissionMatrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is agenda input to nelemGet");

  }


  return MRecord(1001,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfVector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfVector since it is agenda input to nelemGet");

  }


  return MRecord(1002,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfXsecRecord v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceArrayOfXsecRecord since it is agenda input to nelemGet");

  }


  return MRecord(1003,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nelemGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceVector since it is agenda input to nelemGet");

  }


  return MRecord(1004,

    Group::ArrayOfIndex({183, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ncolsGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceMatrix since it is agenda input to ncolsGet");

  }


  return MRecord(1005,

    Group::ArrayOfIndex({184, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ncolsGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Sparse v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceSparse since it is agenda input to ncolsGet");

  }


  return MRecord(1006,

    Group::ArrayOfIndex({184, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ncolsGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor3 since it is agenda input to ncolsGet");

  }


  return MRecord(1007,

    Group::ArrayOfIndex({184, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ncolsGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor4 since it is agenda input to ncolsGet");

  }


  return MRecord(1008,

    Group::ArrayOfIndex({184, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ncolsGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor5 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor5 since it is agenda input to ncolsGet");

  }


  return MRecord(1009,

    Group::ArrayOfIndex({184, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ncolsGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor6 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor6 since it is agenda input to ncolsGet");

  }


  return MRecord(1010,

    Group::ArrayOfIndex({184, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ncolsGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor7 since it is agenda input to ncolsGet");

  }


  return MRecord(1011,

    Group::ArrayOfIndex({184, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nrowsGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceMatrix since it is agenda input to nrowsGet");

  }


  return MRecord(1012,

    Group::ArrayOfIndex({185, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nrowsGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Sparse v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceSparse since it is agenda input to nrowsGet");

  }


  return MRecord(1013,

    Group::ArrayOfIndex({185, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nrowsGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor3 since it is agenda input to nrowsGet");

  }


  return MRecord(1014,

    Group::ArrayOfIndex({185, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nrowsGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor4 since it is agenda input to nrowsGet");

  }


  return MRecord(1015,

    Group::ArrayOfIndex({185, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nrowsGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor5 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor5 since it is agenda input to nrowsGet");

  }


  return MRecord(1016,

    Group::ArrayOfIndex({185, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nrowsGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor6 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor6 since it is agenda input to nrowsGet");

  }


  return MRecord(1017,

    Group::ArrayOfIndex({185, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nrowsGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor7 since it is agenda input to nrowsGet");

  }


  return MRecord(1018,

    Group::ArrayOfIndex({185, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord npagesGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor3 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor3 since it is agenda input to npagesGet");

  }


  return MRecord(1019,

    Group::ArrayOfIndex({186, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord npagesGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor4 since it is agenda input to npagesGet");

  }


  return MRecord(1020,

    Group::ArrayOfIndex({186, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord npagesGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor5 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor5 since it is agenda input to npagesGet");

  }


  return MRecord(1021,

    Group::ArrayOfIndex({186, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord npagesGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor6 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor6 since it is agenda input to npagesGet");

  }


  return MRecord(1022,

    Group::ArrayOfIndex({186, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord npagesGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor7 since it is agenda input to npagesGet");

  }


  return MRecord(1023,

    Group::ArrayOfIndex({186, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nbooksGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor4 since it is agenda input to nbooksGet");

  }


  return MRecord(1024,

    Group::ArrayOfIndex({187, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nbooksGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor5 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor5 since it is agenda input to nbooksGet");

  }


  return MRecord(1025,

    Group::ArrayOfIndex({187, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nbooksGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor6 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor6 since it is agenda input to nbooksGet");

  }


  return MRecord(1026,

    Group::ArrayOfIndex({187, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nbooksGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor7 since it is agenda input to nbooksGet");

  }


  return MRecord(1027,

    Group::ArrayOfIndex({187, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nshelvesGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor5 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor5 since it is agenda input to nshelvesGet");

  }


  return MRecord(1028,

    Group::ArrayOfIndex({188, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nshelvesGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor6 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor6 since it is agenda input to nshelvesGet");

  }


  return MRecord(1029,

    Group::ArrayOfIndex({188, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nshelvesGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor7 since it is agenda input to nshelvesGet");

  }


  return MRecord(1030,

    Group::ArrayOfIndex({188, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nvitrinesGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor6 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor6 since it is agenda input to nvitrinesGet");

  }


  return MRecord(1031,

    Group::ArrayOfIndex({189, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nvitrinesGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor7 since it is agenda input to nvitrinesGet");

  }


  return MRecord(1032,

    Group::ArrayOfIndex({189, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nlibrariesGet(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 v) {

  if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceTensor7 since it is agenda input to nlibrariesGet");

  }


  return MRecord(1033,

    Group::ArrayOfIndex({190, }),

    Group::ArrayOfIndex({Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nlte_sourceFromTemperatureAndSrcCoefPerSpecies(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1034,

    Group::ArrayOfIndex({192, 78, 79, }),

    Group::ArrayOfIndex({309, 70, 137, 104, 264, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nlteOff(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1035,

    Group::ArrayOfIndex({191, 339, 179, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nlteSetByQuantumIdentifiers(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1036,

    Group::ArrayOfIndex({191, 11, }),

    Group::ArrayOfIndex({339, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nlte_fieldFromRaw(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 data) {

  if (data.islast()) {

    throw std::runtime_error("data needs to be a defined WorkspaceTensor4 since it is agenda input to nlte_fieldFromRaw");

  }


  return MRecord(1037,

    Group::ArrayOfIndex({339, }),

    Group::ArrayOfIndex({179, 180, Group::Index(data.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nlte_fieldSetLteExternalPartitionFunction(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1038,

    Group::ArrayOfIndex({191, 339, 11, }),

    Group::ArrayOfIndex({179, 200, 338, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ArrayOfQuantumIdentifierFromLines(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfQuantumIdentifier out,

               const Var::Index& global={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of ArrayOfQuantumIdentifierFromLines");

  } if (not global.isnull() and global.islast()) {

    throw std::runtime_error("global needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ArrayOfQuantumIdentifierFromLines");

  }


  static const auto global_default = Var::IndexCreate(ws, 1,

    "ArrayOfQuantumIdentifierFromLines_global_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1039,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({11, global.isnull() ? Index(global_default.pos()) : Group::Index(global.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord nlte_fieldSetLteInternalPartitionFunction(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1040,

    Group::ArrayOfIndex({191, 339, 11, }),

    Group::ArrayOfIndex({179, 338, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord timeNow(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1041,

    Group::ArrayOfIndex({333, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord timeOffset(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric offset) {

  if (offset.islast()) {

    throw std::runtime_error("offset needs to be a defined WorkspaceNumeric since it is agenda input to timeOffset");

  }


  return MRecord(1042,

    Group::ArrayOfIndex({333, }),

    Group::ArrayOfIndex({Group::Index(offset.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord OEM(

    [[maybe_unused]] Workspace& ws,

               const Var::String method,

               const Var::Numeric& max_start_cost={},

               const Var::Vector& x_norm={},

               const Var::Index& max_iter={},

               const Var::Numeric& stop_dx={},

               const Var::Vector& lm_ga_settings={},

               const Var::Index& clear_matrices={},

               const Var::Index& display_progress={}) {

  if (method.islast()) {

    throw std::runtime_error("method needs to be a defined WorkspaceString since it is agenda input to OEM");

  } if (not max_start_cost.isnull() and max_start_cost.islast()) {

    throw std::runtime_error("max_start_cost needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to OEM");

  } if (not x_norm.isnull() and x_norm.islast()) {

    throw std::runtime_error("x_norm needs to be a defined WorkspaceVector (or left default) since it is agenda input to OEM");

  } if (not max_iter.isnull() and max_iter.islast()) {

    throw std::runtime_error("max_iter needs to be a defined WorkspaceIndex (or left default) since it is agenda input to OEM");

  } if (not stop_dx.isnull() and stop_dx.islast()) {

    throw std::runtime_error("stop_dx needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to OEM");

  } if (not lm_ga_settings.isnull() and lm_ga_settings.islast()) {

    throw std::runtime_error("lm_ga_settings needs to be a defined WorkspaceVector (or left default) since it is agenda input to OEM");

  } if (not clear_matrices.isnull() and clear_matrices.islast()) {

    throw std::runtime_error("clear_matrices needs to be a defined WorkspaceIndex (or left default) since it is agenda input to OEM");

  } if (not display_progress.isnull() and display_progress.islast()) {

    throw std::runtime_error("display_progress needs to be a defined WorkspaceIndex (or left default) since it is agenda input to OEM");

  }


  static const auto max_start_cost_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::infinity(),

    "OEM_max_start_cost_autodefault",

    "auto generated variable with default from method definition");

  static const auto x_norm_default = Var::VectorCreate(ws, {},

    "OEM_x_norm_autodefault",

    "auto generated variable with default from method definition");

  static const auto max_iter_default = Var::IndexCreate(ws, 10,

    "OEM_max_iter_autodefault",

    "auto generated variable with default from method definition");

  static const auto stop_dx_default = Var::NumericCreate(ws, 0.01,

    "OEM_stop_dx_autodefault",

    "auto generated variable with default from method definition");

  static const auto lm_ga_settings_default = Var::VectorCreate(ws, {},

    "OEM_lm_ga_settings_autodefault",

    "auto generated variable with default from method definition");

  static const auto clear_matrices_default = Var::IndexCreate(ws, 0,

    "OEM_clear_matrices_autodefault",

    "auto generated variable with default from method definition");

  static const auto display_progress_default = Var::IndexCreate(ws, 0,

    "OEM_display_progress_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1043,

    Group::ArrayOfIndex({358, 377, 134, 94, 194, 177, 195, }),

    Group::ArrayOfIndex({359, 60, 360, 58, 137, 115, Group::Index(method.pos()), max_start_cost.isnull() ? Index(max_start_cost_default.pos()) : Group::Index(max_start_cost.pos()), x_norm.isnull() ? Index(x_norm_default.pos()) : Group::Index(x_norm.pos()), max_iter.isnull() ? Index(max_iter_default.pos()) : Group::Index(max_iter.pos()), stop_dx.isnull() ? Index(stop_dx_default.pos()) : Group::Index(stop_dx.pos()), lm_ga_settings.isnull() ? Index(lm_ga_settings_default.pos()) : Group::Index(lm_ga_settings.pos()), clear_matrices.isnull() ? Index(clear_matrices_default.pos()) : Group::Index(clear_matrices.pos()), display_progress.isnull() ? Index(display_progress_default.pos()) : Group::Index(display_progress.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord avkCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1044,

    Group::ArrayOfIndex({39, }),

    Group::ArrayOfIndex({94, 134, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_soCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1045,

    Group::ArrayOfIndex({61, }),

    Group::ArrayOfIndex({94, 58, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord covmat_ssCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1046,

    Group::ArrayOfIndex({62, }),

    Group::ArrayOfIndex({39, 60, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord opt_prop_bulkCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1047,

    Group::ArrayOfIndex({95, 25, }),

    Group::ArrayOfIndex({96, 26, 213, 276, 272, 273, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord opt_prop_sptFromData(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1048,

    Group::ArrayOfIndex({96, 26, }),

    Group::ArrayOfIndex({267, 378, 0, 380, 1, 105, 104, 264, 213, 276, 272, 273, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord opt_prop_sptFromScat_data(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1049,

    Group::ArrayOfIndex({96, 26, }),

    Group::ArrayOfIndex({267, 268, 378, 0, 380, 1, 105, 264, 213, 276, 272, 273, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord opt_prop_sptFromMonoData(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1050,

    Group::ArrayOfIndex({96, 26, }),

    Group::ArrayOfIndex({270, 378, 0, 380, 1, 264, 213, 276, 272, 273, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord output_file_formatSetAscii(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1051,

    Group::ArrayOfIndex({196, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord output_file_formatSetBinary(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1052,

    Group::ArrayOfIndex({196, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord output_file_formatSetZippedAscii(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1053,

    Group::ArrayOfIndex({196, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord particle_bulkprop_fieldClip(

    [[maybe_unused]] Workspace& ws,

               const Var::String bulkprop_name,

               const Var::Numeric& limit_low={},

               const Var::Numeric& limit_high={}) {

  if (bulkprop_name.islast()) {

    throw std::runtime_error("bulkprop_name needs to be a defined WorkspaceString since it is agenda input to particle_bulkprop_fieldClip");

  } if (not limit_low.isnull() and limit_low.islast()) {

    throw std::runtime_error("limit_low needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to particle_bulkprop_fieldClip");

  } if (not limit_high.isnull() and limit_high.islast()) {

    throw std::runtime_error("limit_high needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to particle_bulkprop_fieldClip");

  }


  static const auto limit_low_default = Var::NumericCreate(ws, -std::numeric_limits<Numeric>::infinity(),

    "particle_bulkprop_fieldClip_limit_low_autodefault",

    "auto generated variable with default from method definition");

  static const auto limit_high_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::infinity(),

    "particle_bulkprop_fieldClip_limit_high_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1054,

    Group::ArrayOfIndex({197, }),

    Group::ArrayOfIndex({198, Group::Index(bulkprop_name.pos()), limit_low.isnull() ? Index(limit_low_default.pos()) : Group::Index(limit_low.pos()), limit_high.isnull() ? Index(limit_high_default.pos()) : Group::Index(limit_high.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord particle_bulkprop_fieldPerturb(

    [[maybe_unused]] Workspace& ws,

               const Var::String particle_type,

               const Var::Vector p_ret_grid,

               const Var::Vector lat_ret_grid,

               const Var::Vector lon_ret_grid,

               const Var::Index pert_index,

               const Var::Numeric pert_size,

               const Var::String& pert_mode={}) {

  if (particle_type.islast()) {

    throw std::runtime_error("particle_type needs to be a defined WorkspaceString since it is agenda input to particle_bulkprop_fieldPerturb");

  } if (p_ret_grid.islast()) {

    throw std::runtime_error("p_ret_grid needs to be a defined WorkspaceVector since it is agenda input to particle_bulkprop_fieldPerturb");

  } if (lat_ret_grid.islast()) {

    throw std::runtime_error("lat_ret_grid needs to be a defined WorkspaceVector since it is agenda input to particle_bulkprop_fieldPerturb");

  } if (lon_ret_grid.islast()) {

    throw std::runtime_error("lon_ret_grid needs to be a defined WorkspaceVector since it is agenda input to particle_bulkprop_fieldPerturb");

  } if (pert_index.islast()) {

    throw std::runtime_error("pert_index needs to be a defined WorkspaceIndex since it is agenda input to particle_bulkprop_fieldPerturb");

  } if (pert_size.islast()) {

    throw std::runtime_error("pert_size needs to be a defined WorkspaceNumeric since it is agenda input to particle_bulkprop_fieldPerturb");

  } if (not pert_mode.isnull() and pert_mode.islast()) {

    throw std::runtime_error("pert_mode needs to be a defined WorkspaceString (or left default) since it is agenda input to particle_bulkprop_fieldPerturb");

  }


  static const auto pert_mode_default = Var::StringCreate(ws, "absolute",

    "particle_bulkprop_fieldPerturb_pert_mode_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1055,

    Group::ArrayOfIndex({197, }),

    Group::ArrayOfIndex({35, 242, 139, 147, 198, Group::Index(particle_type.pos()), Group::Index(p_ret_grid.pos()), Group::Index(lat_ret_grid.pos()), Group::Index(lon_ret_grid.pos()), Group::Index(pert_index.pos()), Group::Index(pert_size.pos()), pert_mode.isnull() ? Index(pert_mode_default.pos()) : Group::Index(pert_mode.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord particle_bulkprop_fieldPerturbAtmGrids(

    [[maybe_unused]] Workspace& ws,

               const Var::String particle_type,

               const Var::Index pert_index,

               const Var::Numeric pert_size,

               const Var::String& pert_mode={}) {

  if (particle_type.islast()) {

    throw std::runtime_error("particle_type needs to be a defined WorkspaceString since it is agenda input to particle_bulkprop_fieldPerturbAtmGrids");

  } if (pert_index.islast()) {

    throw std::runtime_error("pert_index needs to be a defined WorkspaceIndex since it is agenda input to particle_bulkprop_fieldPerturbAtmGrids");

  } if (pert_size.islast()) {

    throw std::runtime_error("pert_size needs to be a defined WorkspaceNumeric since it is agenda input to particle_bulkprop_fieldPerturbAtmGrids");

  } if (not pert_mode.isnull() and pert_mode.islast()) {

    throw std::runtime_error("pert_mode needs to be a defined WorkspaceString (or left default) since it is agenda input to particle_bulkprop_fieldPerturbAtmGrids");

  }


  static const auto pert_mode_default = Var::StringCreate(ws, "absolute",

    "particle_bulkprop_fieldPerturbAtmGrids_pert_mode_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1056,

    Group::ArrayOfIndex({197, }),

    Group::ArrayOfIndex({35, 242, 139, 147, 198, Group::Index(particle_type.pos()), Group::Index(pert_index.pos()), Group::Index(pert_size.pos()), pert_mode.isnull() ? Index(pert_mode_default.pos()) : Group::Index(pert_mode.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord particle_massesFromMetaDataSingleCategory(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1057,

    Group::ArrayOfIndex({199, }),

    Group::ArrayOfIndex({275, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord particle_massesFromMetaData(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1058,

    Group::ArrayOfIndex({199, }),

    Group::ArrayOfIndex({275, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord partition_functionsInitFromBuiltin(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1059,

    Group::ArrayOfIndex({200, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord pha_matCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1060,

    Group::ArrayOfIndex({201, }),

    Group::ArrayOfIndex({203, 213, 35, 276, 272, 273, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord pha_mat_sptFromData(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1061,

    Group::ArrayOfIndex({203, }),

    Group::ArrayOfIndex({267, 378, 0, 380, 1, 105, 104, 264, 213, 276, 272, 273, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord pha_mat_sptFromDataDOITOpt(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1062,

    Group::ArrayOfIndex({203, }),

    Group::ArrayOfIndex({205, 270, 89, 0, 380, 1, 264, 213, 276, 272, 273, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord pha_mat_sptFromMonoData(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1063,

    Group::ArrayOfIndex({203, }),

    Group::ArrayOfIndex({270, 89, 0, 380, 1, 264, 213, 276, 272, 273, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord pha_mat_sptFromScat_data(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1064,

    Group::ArrayOfIndex({203, }),

    Group::ArrayOfIndex({267, 268, 378, 0, 380, 1, 105, 264, 213, 276, 272, 273, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord pndFromPsd(

    [[maybe_unused]] Workspace& ws,

               const Var::Index scat_index,

               const Var::Index& quad_order={},

               const Var::Numeric& threshold_se_ext={},

               const Var::Numeric& threshold_ss_ext={},

               const Var::Numeric& threshold_se_pnd={}) {

  if (not quad_order.isnull() and quad_order.islast()) {

    throw std::runtime_error("quad_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to pndFromPsd");

  } if (scat_index.islast()) {

    throw std::runtime_error("scat_index needs to be a defined WorkspaceIndex since it is agenda input to pndFromPsd");

  } if (not threshold_se_ext.isnull() and threshold_se_ext.islast()) {

    throw std::runtime_error("threshold_se_ext needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to pndFromPsd");

  } if (not threshold_ss_ext.isnull() and threshold_ss_ext.islast()) {

    throw std::runtime_error("threshold_ss_ext needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to pndFromPsd");

  } if (not threshold_se_pnd.isnull() and threshold_se_pnd.islast()) {

    throw std::runtime_error("threshold_se_pnd needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to pndFromPsd");

  }


  static const auto quad_order_default = Var::IndexCreate(ws, 1,

    "pndFromPsd_quad_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto threshold_se_ext_default = Var::NumericCreate(ws, 0.02,

    "pndFromPsd_threshold_se_ext_autodefault",

    "auto generated variable with default from method definition");

  static const auto threshold_ss_ext_default = Var::NumericCreate(ws, 1e-8,

    "pndFromPsd_threshold_ss_ext_autodefault",

    "auto generated variable with default from method definition");

  static const auto threshold_se_pnd_default = Var::NumericCreate(ws, 0.02,

    "pndFromPsd_threshold_se_pnd_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1065,

    Group::ArrayOfIndex({212, 73, }),

    Group::ArrayOfIndex({214, 240, 241, 77, 267, 104, 268, quad_order.isnull() ? Index(quad_order_default.pos()) : Group::Index(quad_order.pos()), Group::Index(scat_index.pos()), threshold_se_ext.isnull() ? Index(threshold_se_ext_default.pos()) : Group::Index(threshold_se_ext.pos()), threshold_ss_ext.isnull() ? Index(threshold_ss_ext_default.pos()) : Group::Index(threshold_ss_ext.pos()), threshold_se_pnd.isnull() ? Index(threshold_se_pnd_default.pos()) : Group::Index(threshold_se_pnd.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord pndFromPsdBasic(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& quad_order={}) {

  if (not quad_order.isnull() and quad_order.islast()) {

    throw std::runtime_error("quad_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to pndFromPsdBasic");

  }


  static const auto quad_order_default = Var::IndexCreate(ws, 1,

    "pndFromPsdBasic_quad_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1066,

    Group::ArrayOfIndex({212, 73, }),

    Group::ArrayOfIndex({214, 240, 241, 77, quad_order.isnull() ? Index(quad_order_default.pos()) : Group::Index(quad_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord pnd_fieldCalcFromParticleBulkProps(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1067,

    Group::ArrayOfIndex({213, 75, }),

    Group::ArrayOfIndex({35, 242, 139, 147, 338, 53, 52, 277, 267, 275, 197, 198, 207, 210, 136, 137, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord pnd_fieldCalcFrompnd_field_raw(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& zeropadding={}) {

  if (not zeropadding.isnull() and zeropadding.islast()) {

    throw std::runtime_error("zeropadding needs to be a defined WorkspaceIndex (or left default) since it is agenda input to pnd_fieldCalcFrompnd_field_raw");

  }


  static const auto zeropadding_default = Var::IndexCreate(ws, 0,

    "pnd_fieldCalcFrompnd_field_raw_zeropadding_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1068,

    Group::ArrayOfIndex({213, 75, }),

    Group::ArrayOfIndex({242, 139, 147, 215, 35, 52, 137, zeropadding.isnull() ? Index(zeropadding_default.pos()) : Group::Index(zeropadding.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord pnd_fieldExpand1D(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& nzero={}) {

  if (not nzero.isnull() and nzero.islast()) {

    throw std::runtime_error("nzero needs to be a defined WorkspaceIndex (or left default) since it is agenda input to pnd_fieldExpand1D");

  }


  static const auto nzero_default = Var::IndexCreate(ws, 1,

    "pnd_fieldExpand1D_nzero_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1069,

    Group::ArrayOfIndex({213, }),

    Group::ArrayOfIndex({35, 53, 52, nzero.isnull() ? Index(nzero_default.pos()) : Group::Index(nzero.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord pnd_fieldZero(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1070,

    Group::ArrayOfIndex({213, 75, 267, }),

    Group::ArrayOfIndex({35, 104, 52, 137, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ppath_fieldFromDownUpLimbGeoms(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& nz={}) {

  if (not nz.isnull() and nz.islast()) {

    throw std::runtime_error("nz needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ppath_fieldFromDownUpLimbGeoms");

  }


  static const auto nz_default = Var::IndexCreate(ws, 3,

    "ppath_fieldFromDownUpLimbGeoms_nz_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1071,

    Group::ArrayOfIndex({218, }),

    Group::ArrayOfIndex({217, 220, 221, 37, 381, 104, 53, 48, 219, 258, 257, 259, 250, 35, nz.isnull() ? Index(nz_default.pos()) : Group::Index(nz.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ppathCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1072,

    Group::ArrayOfIndex({216, }),

    Group::ArrayOfIndex({217, 220, 221, 37, 104, 53, 48, 219, 258, 257, 259, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ppath_fieldCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1073,

    Group::ArrayOfIndex({218, }),

    Group::ArrayOfIndex({217, 220, 221, 37, 104, 53, 48, 219, 286, 283, 259, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ppathCalcFromAltitude(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric altitude,

               const Var::Numeric& accuracy={}) {

  if (altitude.islast()) {

    throw std::runtime_error("altitude needs to be a defined WorkspaceNumeric since it is agenda input to ppathCalcFromAltitude");

  } if (not accuracy.isnull() and accuracy.islast()) {

    throw std::runtime_error("accuracy needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ppathCalcFromAltitude");

  }


  static const auto accuracy_default = Var::NumericCreate(ws, 0.5,

    "ppathCalcFromAltitude_accuracy_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1074,

    Group::ArrayOfIndex({216, }),

    Group::ArrayOfIndex({217, 220, 221, 37, 104, 53, 48, 219, 258, 257, 259, Group::Index(altitude.pos()), accuracy.isnull() ? Index(accuracy_default.pos()) : Group::Index(accuracy.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ppathFromRtePos2(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& za_accuracy={},

               const Var::Numeric& pplrt_factor={},

               const Var::Numeric& pplrt_lowest={}) {

  if (not za_accuracy.isnull() and za_accuracy.islast()) {

    throw std::runtime_error("za_accuracy needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ppathFromRtePos2");

  } if (not pplrt_factor.isnull() and pplrt_factor.islast()) {

    throw std::runtime_error("pplrt_factor needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ppathFromRtePos2");

  } if (not pplrt_lowest.isnull() and pplrt_lowest.islast()) {

    throw std::runtime_error("pplrt_lowest needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ppathFromRtePos2");

  }


  static const auto za_accuracy_default = Var::NumericCreate(ws, 2e-5,

    "ppathFromRtePos2_za_accuracy_autodefault",

    "auto generated variable with default from method definition");

  static const auto pplrt_factor_default = Var::NumericCreate(ws, 5,

    "ppathFromRtePos2_pplrt_factor_autodefault",

    "auto generated variable with default from method definition");

  static const auto pplrt_lowest_default = Var::NumericCreate(ws, 0.5,

    "ppathFromRtePos2_pplrt_lowest_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1075,

    Group::ArrayOfIndex({216, 257, 221, }),

    Group::ArrayOfIndex({223, 35, 242, 139, 147, 381, 104, 250, 384, 258, 259, 220, za_accuracy.isnull() ? Index(za_accuracy_default.pos()) : Group::Index(za_accuracy.pos()), pplrt_factor.isnull() ? Index(pplrt_factor_default.pos()) : Group::Index(pplrt_factor.pos()), pplrt_lowest.isnull() ? Index(pplrt_lowest_default.pos()) : Group::Index(pplrt_lowest.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ppathPlaneParallel(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1076,

    Group::ArrayOfIndex({216, }),

    Group::ArrayOfIndex({35, 381, 384, 53, 52, 219, 258, 257, 220, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ppathStepByStep(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1077,

    Group::ArrayOfIndex({216, }),

    Group::ArrayOfIndex({223, 219, 35, 242, 139, 147, 381, 104, 250, 384, 53, 52, 258, 257, 220, 221, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ppathWriteXMLPartial(

    [[maybe_unused]] Workspace& ws,

               const Var::String& filename={},

               const Var::Index& file_index={}) {

  if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ppathWriteXMLPartial");

  } if (not file_index.isnull() and file_index.islast()) {

    throw std::runtime_error("file_index needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ppathWriteXMLPartial");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ppathWriteXMLPartial_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto file_index_default = Var::IndexCreate(ws, -1,

    "ppathWriteXMLPartial_file_index_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1078,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 216, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), file_index.isnull() ? Index(file_index_default.pos()) : Group::Index(file_index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ppath_stepGeometric(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1079,

    Group::ArrayOfIndex({222, }),

    Group::ArrayOfIndex({35, 139, 147, 381, 250, 384, 220, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ppath_stepRefractionBasic(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1080,

    Group::ArrayOfIndex({222, }),

    Group::ArrayOfIndex({248, 35, 242, 139, 147, 381, 338, 344, 250, 384, 104, 220, 221, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ppvar_optical_depthFromPpvar_trans_cumulat(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1081,

    Group::ArrayOfIndex({230, }),

    Group::ArrayOfIndex({232, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::AbsorptionLines in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAbsorptionLines since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1082,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Agenda in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAgenda since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1083,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAbsorptionLines in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAbsorptionLines since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1084,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfAbsorptionLines in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1085,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAgenda in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAgenda since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1086,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField1 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1087,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField2 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1088,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField3 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1089,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfIndex in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfIndex since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1090,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfMatrix in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1091,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPpath in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPpath since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1092,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfPropagationMatrix in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1093,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfRadiationVector in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1094,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfScatteringMetaData in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1095,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfSingleScatteringData in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1096,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfSpeciesTag in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1097,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfStokesVector in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1098,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfString in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfString since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1099,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor3 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1100,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor6 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1101,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTime in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTime since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1102,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTransmissionMatrix in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1103,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfVector in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfVector since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1104,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfCIARecord in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfCIARecord since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1105,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField1 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField1 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1106,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField2 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField2 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1107,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField3 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1108,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField4 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField4 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1109,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfIndex in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1110,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfMatrix in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1111,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPropagationMatrix in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPropagationMatrix since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1112,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1113,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRadiationVector in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRadiationVector since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1114,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRetrievalQuantity in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1115,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfScatteringMetaData in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfScatteringMetaData since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1116,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfSingleScatteringData in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSingleScatteringData since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1117,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfSparse in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSparse since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1118,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfStokesVector in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfStokesVector since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1119,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfString in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfString since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1120,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTelsemAtlas in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTelsemAtlas since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1121,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor3 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor3 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1122,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor4 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor4 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1123,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor5 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor5 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1124,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor6 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor6 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1125,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor7 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor7 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1126,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTime in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTime since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1127,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTransmissionMatrix in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1128,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfVector in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfVector since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1129,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfXsecRecord in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfXsecRecord since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1130,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::CIARecord in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCIARecord since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1131,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::CovarianceMatrix in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCovarianceMatrix since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1132,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::EnergyLevelMap in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceEnergyLevelMap since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1133,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::GasAbsLookup in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGasAbsLookup since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1134,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::GridPos in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGridPos since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1135,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField1 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField1 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1136,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField2 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField2 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1137,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField3 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField3 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1138,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField4 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField4 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1139,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField5 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField5 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1140,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField6 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField6 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1141,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::HitranRelaxationMatrixData in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceHitranRelaxationMatrixData since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1142,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Index in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceIndex since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1143,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::MCAntenna in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMCAntenna since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1144,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1145,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceNumeric since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1146,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Ppath in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePpath since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1147,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::PropagationMatrix in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePropagationMatrix since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1148,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1149,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::RadiationVector in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRadiationVector since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1150,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Rational in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRational since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1151,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::ScatteringMetaData in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceScatteringMetaData since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1152,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::SingleScatteringData in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSingleScatteringData since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1153,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Sparse in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSparse since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1154,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::SpeciesAuxData in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSpeciesAuxData since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1155,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::StokesVector in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceStokesVector since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1156,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::String in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceString since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1157,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::TelsemAtlas in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTelsemAtlas since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1158,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor3 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1159,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1160,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor5 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor5 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1161,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor6 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor6 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1162,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor7 since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1163,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Timer in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTimer since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1164,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Time in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTime since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1165,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::TessemNN in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTessemNN since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1166,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::TransmissionMatrix in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTransmissionMatrix since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1167,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1168,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Print(

    [[maybe_unused]] Workspace& ws,

               const Var::Verbosity in,

               const Var::Index& level={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVerbosity since it is agenda input to Print");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Print");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "Print_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1169,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord PrintPhysicalConstants(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1170,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord PrintWorkspace(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& only_allocated={},

               const Var::Index& level={}) {

  if (not only_allocated.isnull() and only_allocated.islast()) {

    throw std::runtime_error("only_allocated needs to be a defined WorkspaceIndex (or left default) since it is agenda input to PrintWorkspace");

  } if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to PrintWorkspace");

  }


  static const auto only_allocated_default = Var::IndexCreate(ws, 1,

    "PrintWorkspace_only_allocated_autodefault",

    "auto generated variable with default from method definition");

  static const auto level_default = Var::IndexCreate(ws, 1,

    "PrintWorkspace_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1171,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({only_allocated.isnull() ? Index(only_allocated_default.pos()) : Group::Index(only_allocated.pos()), level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ZFromPSimple(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector z_grid,

               const Var::Vector p_grid) {

  if (z_grid.islast()) {

    throw std::runtime_error("z_grid needs to be a defined WorkspaceVector since it is output of ZFromPSimple");

  } if (p_grid.islast()) {

    throw std::runtime_error("p_grid needs to be a defined WorkspaceVector since it is agenda input to ZFromPSimple");

  }


  return MRecord(1172,

    Group::ArrayOfIndex({Group::Index(z_grid.pos()), }),

    Group::ArrayOfIndex({Group::Index(p_grid.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord PFromZSimple(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector p_grid,

               const Var::Vector z_grid) {

  if (p_grid.islast()) {

    throw std::runtime_error("p_grid needs to be a defined WorkspaceVector since it is output of PFromZSimple");

  } if (z_grid.islast()) {

    throw std::runtime_error("z_grid needs to be a defined WorkspaceVector since it is agenda input to PFromZSimple");

  }


  return MRecord(1173,

    Group::ArrayOfIndex({Group::Index(p_grid.pos()), }),

    Group::ArrayOfIndex({Group::Index(z_grid.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord propmat_clearskyAddFaraday(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1174,

    Group::ArrayOfIndex({236, 76, }),

    Group::ArrayOfIndex({306, 35, 104, 21, 137, 266, 261, 260, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord propmat_clearskyAddFromAbsCoefPerSpecies(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1175,

    Group::ArrayOfIndex({236, 76, }),

    Group::ArrayOfIndex({4, 63, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord propmat_clearskyAddFromLookup(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& extpolfac={}) {

  if (not extpolfac.isnull() and extpolfac.islast()) {

    throw std::runtime_error("extpolfac needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to propmat_clearskyAddFromLookup");

  }


  static const auto extpolfac_default = Var::NumericCreate(ws, 0.5,

    "propmat_clearskyAddFromLookup_extpolfac_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1176,

    Group::ArrayOfIndex({236, 76, }),

    Group::ArrayOfIndex({12, 19, 16, 18, 15, 8, 104, 263, 264, 266, 137, extpolfac.isnull() ? Index(extpolfac_default.pos()) : Group::Index(extpolfac.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord propmat_clearskyAddHitranLineMixingLines(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1177,

    Group::ArrayOfIndex({236, }),

    Group::ArrayOfIndex({9, 11, 104, 21, 137, 200, 263, 264, 266, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord propmat_clearskyAddOnTheFly(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1178,

    Group::ArrayOfIndex({236, 192, 76, 78, 79, }),

    Group::ArrayOfIndex({104, 21, 137, 263, 264, 265, 266, 29, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord propmat_clearskyAddParticles(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& use_abs_as_ext={}) {

  if (not use_abs_as_ext.isnull() and use_abs_as_ext.islast()) {

    throw std::runtime_error("use_abs_as_ext needs to be a defined WorkspaceIndex (or left default) since it is agenda input to propmat_clearskyAddParticles");

  }


  static const auto use_abs_as_ext_default = Var::IndexCreate(ws, 1,

    "propmat_clearskyAddParticles_use_abs_as_ext_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1179,

    Group::ArrayOfIndex({236, 76, }),

    Group::ArrayOfIndex({306, 35, 104, 21, 137, 266, 261, 264, 267, 268, use_abs_as_ext.isnull() ? Index(use_abs_as_ext_default.pos()) : Group::Index(use_abs_as_ext.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord propmat_clearskyAddZeeman(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& manual_zeeman_tag={},

               const Var::Numeric& manual_zeeman_magnetic_field_strength={},

               const Var::Numeric& manual_zeeman_theta={},

               const Var::Numeric& manual_zeeman_eta={}) {

  if (not manual_zeeman_tag.isnull() and manual_zeeman_tag.islast()) {

    throw std::runtime_error("manual_zeeman_tag needs to be a defined WorkspaceIndex (or left default) since it is agenda input to propmat_clearskyAddZeeman");

  } if (not manual_zeeman_magnetic_field_strength.isnull() and manual_zeeman_magnetic_field_strength.islast()) {

    throw std::runtime_error("manual_zeeman_magnetic_field_strength needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to propmat_clearskyAddZeeman");

  } if (not manual_zeeman_theta.isnull() and manual_zeeman_theta.islast()) {

    throw std::runtime_error("manual_zeeman_theta needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to propmat_clearskyAddZeeman");

  } if (not manual_zeeman_eta.isnull() and manual_zeeman_eta.islast()) {

    throw std::runtime_error("manual_zeeman_eta needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to propmat_clearskyAddZeeman");

  }


  static const auto manual_zeeman_tag_default = Var::IndexCreate(ws, 0,

    "propmat_clearskyAddZeeman_manual_zeeman_tag_autodefault",

    "auto generated variable with default from method definition");

  static const auto manual_zeeman_magnetic_field_strength_default = Var::NumericCreate(ws, 1.0,

    "propmat_clearskyAddZeeman_manual_zeeman_magnetic_field_strength_autodefault",

    "auto generated variable with default from method definition");

  static const auto manual_zeeman_theta_default = Var::NumericCreate(ws, 0.0,

    "propmat_clearskyAddZeeman_manual_zeeman_theta_autodefault",

    "auto generated variable with default from method definition");

  static const auto manual_zeeman_eta_default = Var::NumericCreate(ws, 0.0,

    "propmat_clearskyAddZeeman_manual_zeeman_eta_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1180,

    Group::ArrayOfIndex({236, 192, 76, 78, 79, }),

    Group::ArrayOfIndex({11, 104, 21, 137, 117, 200, 263, 264, 265, 266, 260, 261, 35, 141, manual_zeeman_tag.isnull() ? Index(manual_zeeman_tag_default.pos()) : Group::Index(manual_zeeman_tag.pos()), manual_zeeman_magnetic_field_strength.isnull() ? Index(manual_zeeman_magnetic_field_strength_default.pos()) : Group::Index(manual_zeeman_magnetic_field_strength.pos()), manual_zeeman_theta.isnull() ? Index(manual_zeeman_theta_default.pos()) : Group::Index(manual_zeeman_theta.pos()), manual_zeeman_eta.isnull() ? Index(manual_zeeman_eta_default.pos()) : Group::Index(manual_zeeman_eta.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord propmat_clearskyInit(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1181,

    Group::ArrayOfIndex({236, 192, 76, 78, 79, }),

    Group::ArrayOfIndex({21, 137, 104, 306, 237, 191, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord propmat_clearskyZero(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1182,

    Group::ArrayOfIndex({236, }),

    Group::ArrayOfIndex({104, 306, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord propmat_clearskyForceNegativeToZero(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1183,

    Group::ArrayOfIndex({236, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord propmat_clearsky_agenda_checkedCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1184,

    Group::ArrayOfIndex({237, }),

    Group::ArrayOfIndex({21, 238, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord propmat_clearsky_fieldCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector& doppler={},

               const Var::Vector& los={}) {

  if (not doppler.isnull() and doppler.islast()) {

    throw std::runtime_error("doppler needs to be a defined WorkspaceVector (or left default) since it is agenda input to propmat_clearsky_fieldCalc");

  } if (not los.isnull() and los.islast()) {

    throw std::runtime_error("los needs to be a defined WorkspaceVector (or left default) since it is agenda input to propmat_clearsky_fieldCalc");

  }


  static const auto doppler_default = Var::VectorCreate(ws, {},

    "propmat_clearsky_fieldCalc_doppler_autodefault",

    "auto generated variable with default from method definition");

  static const auto los_default = Var::VectorCreate(ws, {},

    "propmat_clearsky_fieldCalc_los_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1185,

    Group::ArrayOfIndex({239, 193, }),

    Group::ArrayOfIndex({36, 104, 306, 242, 139, 147, 338, 344, 339, 149, 151, 153, 238, doppler.isnull() ? Index(doppler_default.pos()) : Group::Index(doppler.pos()), los.isnull() ? Index(los_default.pos()) : Group::Index(los.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdAbelBoutle12(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& t_min={},

               const Var::Numeric& t_max={},

               const Var::Index& picky={}) {

  if (not t_min.isnull() and t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdAbelBoutle12");

  } if (not t_max.isnull() and t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdAbelBoutle12");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdAbelBoutle12");

  }


  static const auto t_min_default = Var::NumericCreate(ws, 273,

    "psdAbelBoutle12_t_min_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_max_default = Var::NumericCreate(ws, 373,

    "psdAbelBoutle12_t_max_autodefault",

    "auto generated variable with default from method definition");

  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdAbelBoutle12_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1186,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, 278, 279, t_min.isnull() ? Index(t_min_default.pos()) : Group::Index(t_min.pos()), t_max.isnull() ? Index(t_max_default.pos()) : Group::Index(t_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdDelanoeEtAl14(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric t_min,

               const Var::Numeric t_max,

               const Var::Numeric& iwc={},

               const Var::Numeric& n0Star={},

               const Var::Numeric& Dm={},

               const Var::Numeric& rho={},

               const Var::Numeric& alpha={},

               const Var::Numeric& beta={},

               const Var::Numeric& dm_min={},

               const Var::Index& picky={}) {

  if (not iwc.isnull() and iwc.islast()) {

    throw std::runtime_error("iwc needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdDelanoeEtAl14");

  } if (not n0Star.isnull() and n0Star.islast()) {

    throw std::runtime_error("n0Star needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdDelanoeEtAl14");

  } if (not Dm.isnull() and Dm.islast()) {

    throw std::runtime_error("Dm needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdDelanoeEtAl14");

  } if (not rho.isnull() and rho.islast()) {

    throw std::runtime_error("rho needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdDelanoeEtAl14");

  } if (not alpha.isnull() and alpha.islast()) {

    throw std::runtime_error("alpha needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdDelanoeEtAl14");

  } if (not beta.isnull() and beta.islast()) {

    throw std::runtime_error("beta needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdDelanoeEtAl14");

  } if (t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric since it is agenda input to psdDelanoeEtAl14");

  } if (t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric since it is agenda input to psdDelanoeEtAl14");

  } if (not dm_min.isnull() and dm_min.islast()) {

    throw std::runtime_error("dm_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdDelanoeEtAl14");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdDelanoeEtAl14");

  }


  static const auto iwc_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdDelanoeEtAl14_iwc_autodefault",

    "auto generated variable with default from method definition");

  static const auto n0Star_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdDelanoeEtAl14_n0Star_autodefault",

    "auto generated variable with default from method definition");

  static const auto Dm_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdDelanoeEtAl14_Dm_autodefault",

    "auto generated variable with default from method definition");

  static const auto rho_default = Var::NumericCreate(ws, 917.6,

    "psdDelanoeEtAl14_rho_autodefault",

    "auto generated variable with default from method definition");

  static const auto alpha_default = Var::NumericCreate(ws, -0.237,

    "psdDelanoeEtAl14_alpha_autodefault",

    "auto generated variable with default from method definition");

  static const auto beta_default = Var::NumericCreate(ws, 1.839,

    "psdDelanoeEtAl14_beta_autodefault",

    "auto generated variable with default from method definition");

  static const auto dm_min_default = Var::NumericCreate(ws, -1.0,

    "psdDelanoeEtAl14_dm_min_autodefault",

    "auto generated variable with default from method definition");

  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdDelanoeEtAl14_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1187,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, iwc.isnull() ? Index(iwc_default.pos()) : Group::Index(iwc.pos()), n0Star.isnull() ? Index(n0Star_default.pos()) : Group::Index(n0Star.pos()), Dm.isnull() ? Index(Dm_default.pos()) : Group::Index(Dm.pos()), rho.isnull() ? Index(rho_default.pos()) : Group::Index(rho.pos()), alpha.isnull() ? Index(alpha_default.pos()) : Group::Index(alpha.pos()), beta.isnull() ? Index(beta_default.pos()) : Group::Index(beta.pos()), Group::Index(t_min.pos()), Group::Index(t_max.pos()), dm_min.isnull() ? Index(dm_min_default.pos()) : Group::Index(dm_min.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdFieldEtAl07(

    [[maybe_unused]] Workspace& ws,

               const Var::String regime,

               const Var::Numeric& t_min={},

               const Var::Numeric& t_max={},

               const Var::Numeric& t_min_psd={},

               const Var::Numeric& t_max_psd={},

               const Var::Numeric& beta_min={},

               const Var::Numeric& beta_max={},

               const Var::Index& picky={}) {

  if (regime.islast()) {

    throw std::runtime_error("regime needs to be a defined WorkspaceString since it is agenda input to psdFieldEtAl07");

  } if (not t_min.isnull() and t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdFieldEtAl07");

  } if (not t_max.isnull() and t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdFieldEtAl07");

  } if (not t_min_psd.isnull() and t_min_psd.islast()) {

    throw std::runtime_error("t_min_psd needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdFieldEtAl07");

  } if (not t_max_psd.isnull() and t_max_psd.islast()) {

    throw std::runtime_error("t_max_psd needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdFieldEtAl07");

  } if (not beta_min.isnull() and beta_min.islast()) {

    throw std::runtime_error("beta_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdFieldEtAl07");

  } if (not beta_max.isnull() and beta_max.islast()) {

    throw std::runtime_error("beta_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdFieldEtAl07");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdFieldEtAl07");

  }


  static const auto t_min_default = Var::NumericCreate(ws, 0,

    "psdFieldEtAl07_t_min_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_max_default = Var::NumericCreate(ws, 290.,

    "psdFieldEtAl07_t_max_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_min_psd_default = Var::NumericCreate(ws, 200.,

    "psdFieldEtAl07_t_min_psd_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_max_psd_default = Var::NumericCreate(ws, 273.15,

    "psdFieldEtAl07_t_max_psd_autodefault",

    "auto generated variable with default from method definition");

  static const auto beta_min_default = Var::NumericCreate(ws, 1.01,

    "psdFieldEtAl07_beta_min_autodefault",

    "auto generated variable with default from method definition");

  static const auto beta_max_default = Var::NumericCreate(ws, 4,

    "psdFieldEtAl07_beta_max_autodefault",

    "auto generated variable with default from method definition");

  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdFieldEtAl07_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1188,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, 278, 279, Group::Index(regime.pos()), t_min.isnull() ? Index(t_min_default.pos()) : Group::Index(t_min.pos()), t_max.isnull() ? Index(t_max_default.pos()) : Group::Index(t_max.pos()), t_min_psd.isnull() ? Index(t_min_psd_default.pos()) : Group::Index(t_min_psd.pos()), t_max_psd.isnull() ? Index(t_max_psd_default.pos()) : Group::Index(t_max_psd.pos()), beta_min.isnull() ? Index(beta_min_default.pos()) : Group::Index(beta_min.pos()), beta_max.isnull() ? Index(beta_max_default.pos()) : Group::Index(beta_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdFieldEtAl19(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric t_min,

               const Var::Numeric t_max,

               const Var::Index& picky={}) {

  if (t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric since it is agenda input to psdFieldEtAl19");

  } if (t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric since it is agenda input to psdFieldEtAl19");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdFieldEtAl19");

  }


  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdFieldEtAl19_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1189,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, 278, 279, Group::Index(t_min.pos()), Group::Index(t_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdMcFarquaharHeymsfield97(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& t_min={},

               const Var::Numeric& t_max={},

               const Var::Numeric& t_min_psd={},

               const Var::Numeric& t_max_psd={},

               const Var::Index& picky={},

               const Var::Index& noisy={}) {

  if (not t_min.isnull() and t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdMcFarquaharHeymsfield97");

  } if (not t_max.isnull() and t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdMcFarquaharHeymsfield97");

  } if (not t_min_psd.isnull() and t_min_psd.islast()) {

    throw std::runtime_error("t_min_psd needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdMcFarquaharHeymsfield97");

  } if (not t_max_psd.isnull() and t_max_psd.islast()) {

    throw std::runtime_error("t_max_psd needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdMcFarquaharHeymsfield97");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdMcFarquaharHeymsfield97");

  } if (not noisy.isnull() and noisy.islast()) {

    throw std::runtime_error("noisy needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdMcFarquaharHeymsfield97");

  }


  static const auto t_min_default = Var::NumericCreate(ws, 0,

    "psdMcFarquaharHeymsfield97_t_min_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_max_default = Var::NumericCreate(ws, 280.,

    "psdMcFarquaharHeymsfield97_t_max_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_min_psd_default = Var::NumericCreate(ws, 180,

    "psdMcFarquaharHeymsfield97_t_min_psd_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_max_psd_default = Var::NumericCreate(ws, 273.15,

    "psdMcFarquaharHeymsfield97_t_max_psd_autodefault",

    "auto generated variable with default from method definition");

  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdMcFarquaharHeymsfield97_picky_autodefault",

    "auto generated variable with default from method definition");

  static const auto noisy_default = Var::IndexCreate(ws, 0,

    "psdMcFarquaharHeymsfield97_noisy_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1190,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, 278, 279, t_min.isnull() ? Index(t_min_default.pos()) : Group::Index(t_min.pos()), t_max.isnull() ? Index(t_max_default.pos()) : Group::Index(t_max.pos()), t_min_psd.isnull() ? Index(t_min_psd_default.pos()) : Group::Index(t_min_psd.pos()), t_max_psd.isnull() ? Index(t_max_psd_default.pos()) : Group::Index(t_max_psd.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), noisy.isnull() ? Index(noisy_default.pos()) : Group::Index(noisy.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdMilbrandtYau05(

    [[maybe_unused]] Workspace& ws,

               const Var::String hydrometeor_type,

               const Var::Numeric& t_min={},

               const Var::Numeric& t_max={},

               const Var::Index& picky={}) {

  if (hydrometeor_type.islast()) {

    throw std::runtime_error("hydrometeor_type needs to be a defined WorkspaceString since it is agenda input to psdMilbrandtYau05");

  } if (not t_min.isnull() and t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdMilbrandtYau05");

  } if (not t_max.isnull() and t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdMilbrandtYau05");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdMilbrandtYau05");

  }


  static const auto t_min_default = Var::NumericCreate(ws, 0,

    "psdMilbrandtYau05_t_min_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_max_default = Var::NumericCreate(ws, 999,

    "psdMilbrandtYau05_t_max_autodefault",

    "auto generated variable with default from method definition");

  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdMilbrandtYau05_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1191,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, Group::Index(hydrometeor_type.pos()), t_min.isnull() ? Index(t_min_default.pos()) : Group::Index(t_min.pos()), t_max.isnull() ? Index(t_max_default.pos()) : Group::Index(t_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdModifiedGamma(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric t_min,

               const Var::Numeric t_max,

               const Var::Numeric& n0={},

               const Var::Numeric& mu={},

               const Var::Numeric& la={},

               const Var::Numeric& ga={},

               const Var::Index& picky={}) {

  if (not n0.isnull() and n0.islast()) {

    throw std::runtime_error("n0 needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGamma");

  } if (not mu.isnull() and mu.islast()) {

    throw std::runtime_error("mu needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGamma");

  } if (not la.isnull() and la.islast()) {

    throw std::runtime_error("la needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGamma");

  } if (not ga.isnull() and ga.islast()) {

    throw std::runtime_error("ga needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGamma");

  } if (t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGamma");

  } if (t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGamma");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdModifiedGamma");

  }


  static const auto n0_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGamma_n0_autodefault",

    "auto generated variable with default from method definition");

  static const auto mu_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGamma_mu_autodefault",

    "auto generated variable with default from method definition");

  static const auto la_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGamma_la_autodefault",

    "auto generated variable with default from method definition");

  static const auto ga_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGamma_ga_autodefault",

    "auto generated variable with default from method definition");

  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdModifiedGamma_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1192,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, n0.isnull() ? Index(n0_default.pos()) : Group::Index(n0.pos()), mu.isnull() ? Index(mu_default.pos()) : Group::Index(mu.pos()), la.isnull() ? Index(la_default.pos()) : Group::Index(la.pos()), ga.isnull() ? Index(ga_default.pos()) : Group::Index(ga.pos()), Group::Index(t_min.pos()), Group::Index(t_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdModifiedGammaMass(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric t_min,

               const Var::Numeric t_max,

               const Var::Numeric& n0={},

               const Var::Numeric& mu={},

               const Var::Numeric& la={},

               const Var::Numeric& ga={},

               const Var::Index& picky={}) {

  if (not n0.isnull() and n0.islast()) {

    throw std::runtime_error("n0 needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMass");

  } if (not mu.isnull() and mu.islast()) {

    throw std::runtime_error("mu needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMass");

  } if (not la.isnull() and la.islast()) {

    throw std::runtime_error("la needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMass");

  } if (not ga.isnull() and ga.islast()) {

    throw std::runtime_error("ga needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMass");

  } if (t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMass");

  } if (t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMass");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdModifiedGammaMass");

  }


  static const auto n0_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMass_n0_autodefault",

    "auto generated variable with default from method definition");

  static const auto mu_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMass_mu_autodefault",

    "auto generated variable with default from method definition");

  static const auto la_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMass_la_autodefault",

    "auto generated variable with default from method definition");

  static const auto ga_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMass_ga_autodefault",

    "auto generated variable with default from method definition");

  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdModifiedGammaMass_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1193,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, 278, 279, n0.isnull() ? Index(n0_default.pos()) : Group::Index(n0.pos()), mu.isnull() ? Index(mu_default.pos()) : Group::Index(mu.pos()), la.isnull() ? Index(la_default.pos()) : Group::Index(la.pos()), ga.isnull() ? Index(ga_default.pos()) : Group::Index(ga.pos()), Group::Index(t_min.pos()), Group::Index(t_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdModifiedGammaMassNtot(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric t_min,

               const Var::Numeric t_max,

               const Var::Numeric& n0={},

               const Var::Numeric& mu={},

               const Var::Numeric& la={},

               const Var::Numeric& ga={},

               const Var::Index& picky={}) {

  if (not n0.isnull() and n0.islast()) {

    throw std::runtime_error("n0 needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassNtot");

  } if (not mu.isnull() and mu.islast()) {

    throw std::runtime_error("mu needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassNtot");

  } if (not la.isnull() and la.islast()) {

    throw std::runtime_error("la needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassNtot");

  } if (not ga.isnull() and ga.islast()) {

    throw std::runtime_error("ga needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassNtot");

  } if (t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMassNtot");

  } if (t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMassNtot");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdModifiedGammaMassNtot");

  }


  static const auto n0_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassNtot_n0_autodefault",

    "auto generated variable with default from method definition");

  static const auto mu_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassNtot_mu_autodefault",

    "auto generated variable with default from method definition");

  static const auto la_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassNtot_la_autodefault",

    "auto generated variable with default from method definition");

  static const auto ga_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassNtot_ga_autodefault",

    "auto generated variable with default from method definition");

  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdModifiedGammaMassNtot_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1194,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, 278, 279, n0.isnull() ? Index(n0_default.pos()) : Group::Index(n0.pos()), mu.isnull() ? Index(mu_default.pos()) : Group::Index(mu.pos()), la.isnull() ? Index(la_default.pos()) : Group::Index(la.pos()), ga.isnull() ? Index(ga_default.pos()) : Group::Index(ga.pos()), Group::Index(t_min.pos()), Group::Index(t_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdModifiedGammaMassMeanParticleMass(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric t_min,

               const Var::Numeric t_max,

               const Var::Numeric& n0={},

               const Var::Numeric& mu={},

               const Var::Numeric& la={},

               const Var::Numeric& ga={},

               const Var::Index& picky={}) {

  if (not n0.isnull() and n0.islast()) {

    throw std::runtime_error("n0 needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassMeanParticleMass");

  } if (not mu.isnull() and mu.islast()) {

    throw std::runtime_error("mu needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassMeanParticleMass");

  } if (not la.isnull() and la.islast()) {

    throw std::runtime_error("la needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassMeanParticleMass");

  } if (not ga.isnull() and ga.islast()) {

    throw std::runtime_error("ga needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassMeanParticleMass");

  } if (t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMassMeanParticleMass");

  } if (t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMassMeanParticleMass");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdModifiedGammaMassMeanParticleMass");

  }


  static const auto n0_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassMeanParticleMass_n0_autodefault",

    "auto generated variable with default from method definition");

  static const auto mu_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassMeanParticleMass_mu_autodefault",

    "auto generated variable with default from method definition");

  static const auto la_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassMeanParticleMass_la_autodefault",

    "auto generated variable with default from method definition");

  static const auto ga_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassMeanParticleMass_ga_autodefault",

    "auto generated variable with default from method definition");

  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdModifiedGammaMassMeanParticleMass_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1195,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, 278, 279, n0.isnull() ? Index(n0_default.pos()) : Group::Index(n0.pos()), mu.isnull() ? Index(mu_default.pos()) : Group::Index(mu.pos()), la.isnull() ? Index(la_default.pos()) : Group::Index(la.pos()), ga.isnull() ? Index(ga_default.pos()) : Group::Index(ga.pos()), Group::Index(t_min.pos()), Group::Index(t_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdModifiedGammaMassSingleMoment(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric n_alpha,

               const Var::Numeric n_b,

               const Var::Numeric mu,

               const Var::Numeric gamma,

               const Var::Numeric t_min,

               const Var::Numeric t_max,

               const Var::Index& picky={}) {

  if (n_alpha.islast()) {

    throw std::runtime_error("n_alpha needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMassSingleMoment");

  } if (n_b.islast()) {

    throw std::runtime_error("n_b needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMassSingleMoment");

  } if (mu.islast()) {

    throw std::runtime_error("mu needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMassSingleMoment");

  } if (gamma.islast()) {

    throw std::runtime_error("gamma needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMassSingleMoment");

  } if (t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMassSingleMoment");

  } if (t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMassSingleMoment");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdModifiedGammaMassSingleMoment");

  }


  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdModifiedGammaMassSingleMoment_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1196,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, 278, 279, Group::Index(n_alpha.pos()), Group::Index(n_b.pos()), Group::Index(mu.pos()), Group::Index(gamma.pos()), Group::Index(t_min.pos()), Group::Index(t_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdModifiedGammaMassXmean(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric t_min,

               const Var::Numeric t_max,

               const Var::Numeric& n0={},

               const Var::Numeric& mu={},

               const Var::Numeric& la={},

               const Var::Numeric& ga={},

               const Var::Index& picky={}) {

  if (not n0.isnull() and n0.islast()) {

    throw std::runtime_error("n0 needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassXmean");

  } if (not mu.isnull() and mu.islast()) {

    throw std::runtime_error("mu needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassXmean");

  } if (not la.isnull() and la.islast()) {

    throw std::runtime_error("la needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassXmean");

  } if (not ga.isnull() and ga.islast()) {

    throw std::runtime_error("ga needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassXmean");

  } if (t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMassXmean");

  } if (t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMassXmean");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdModifiedGammaMassXmean");

  }


  static const auto n0_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassXmean_n0_autodefault",

    "auto generated variable with default from method definition");

  static const auto mu_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassXmean_mu_autodefault",

    "auto generated variable with default from method definition");

  static const auto la_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassXmean_la_autodefault",

    "auto generated variable with default from method definition");

  static const auto ga_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassXmean_ga_autodefault",

    "auto generated variable with default from method definition");

  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdModifiedGammaMassXmean_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1197,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, 278, 279, n0.isnull() ? Index(n0_default.pos()) : Group::Index(n0.pos()), mu.isnull() ? Index(mu_default.pos()) : Group::Index(mu.pos()), la.isnull() ? Index(la_default.pos()) : Group::Index(la.pos()), ga.isnull() ? Index(ga_default.pos()) : Group::Index(ga.pos()), Group::Index(t_min.pos()), Group::Index(t_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdModifiedGammaMassXmedian(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric t_min,

               const Var::Numeric t_max,

               const Var::Numeric& n0={},

               const Var::Numeric& mu={},

               const Var::Numeric& la={},

               const Var::Numeric& ga={},

               const Var::Index& picky={}) {

  if (not n0.isnull() and n0.islast()) {

    throw std::runtime_error("n0 needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassXmedian");

  } if (not mu.isnull() and mu.islast()) {

    throw std::runtime_error("mu needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassXmedian");

  } if (not la.isnull() and la.islast()) {

    throw std::runtime_error("la needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassXmedian");

  } if (not ga.isnull() and ga.islast()) {

    throw std::runtime_error("ga needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdModifiedGammaMassXmedian");

  } if (t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMassXmedian");

  } if (t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric since it is agenda input to psdModifiedGammaMassXmedian");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdModifiedGammaMassXmedian");

  }


  static const auto n0_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassXmedian_n0_autodefault",

    "auto generated variable with default from method definition");

  static const auto mu_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassXmedian_mu_autodefault",

    "auto generated variable with default from method definition");

  static const auto la_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassXmedian_la_autodefault",

    "auto generated variable with default from method definition");

  static const auto ga_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "psdModifiedGammaMassXmedian_ga_autodefault",

    "auto generated variable with default from method definition");

  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdModifiedGammaMassXmedian_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1198,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, 278, 279, n0.isnull() ? Index(n0_default.pos()) : Group::Index(n0.pos()), mu.isnull() ? Index(mu_default.pos()) : Group::Index(mu.pos()), la.isnull() ? Index(la_default.pos()) : Group::Index(la.pos()), ga.isnull() ? Index(ga_default.pos()) : Group::Index(ga.pos()), Group::Index(t_min.pos()), Group::Index(t_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdMonoDispersive(

    [[maybe_unused]] Workspace& ws,

               const Var::Index species_index,

               const Var::Numeric t_min,

               const Var::Numeric t_max,

               const Var::Index& picky={}) {

  if (species_index.islast()) {

    throw std::runtime_error("species_index needs to be a defined WorkspaceIndex since it is agenda input to psdMonoDispersive");

  } if (t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric since it is agenda input to psdMonoDispersive");

  } if (t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric since it is agenda input to psdMonoDispersive");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdMonoDispersive");

  }


  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdMonoDispersive_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1199,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({209, 208, 211, 74, 275, Group::Index(species_index.pos()), Group::Index(t_min.pos()), Group::Index(t_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdMonoMass(

    [[maybe_unused]] Workspace& ws,

               const Var::Index species_index,

               const Var::Numeric t_min,

               const Var::Numeric t_max,

               const Var::Index& picky={}) {

  if (species_index.islast()) {

    throw std::runtime_error("species_index needs to be a defined WorkspaceIndex since it is agenda input to psdMonoMass");

  } if (t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric since it is agenda input to psdMonoMass");

  } if (t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric since it is agenda input to psdMonoMass");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdMonoMass");

  }


  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdMonoMass_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1200,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({209, 208, 211, 74, 275, Group::Index(species_index.pos()), Group::Index(t_min.pos()), Group::Index(t_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdSeifertBeheng06(

    [[maybe_unused]] Workspace& ws,

               const Var::String hydrometeor_type,

               const Var::Numeric& t_min={},

               const Var::Numeric& t_max={},

               const Var::Index& picky={}) {

  if (hydrometeor_type.islast()) {

    throw std::runtime_error("hydrometeor_type needs to be a defined WorkspaceString since it is agenda input to psdSeifertBeheng06");

  } if (not t_min.isnull() and t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdSeifertBeheng06");

  } if (not t_max.isnull() and t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdSeifertBeheng06");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdSeifertBeheng06");

  }


  static const auto t_min_default = Var::NumericCreate(ws, 0,

    "psdSeifertBeheng06_t_min_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_max_default = Var::NumericCreate(ws, 999,

    "psdSeifertBeheng06_t_max_autodefault",

    "auto generated variable with default from method definition");

  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdSeifertBeheng06_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1201,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, Group::Index(hydrometeor_type.pos()), t_min.isnull() ? Index(t_min_default.pos()) : Group::Index(t_min.pos()), t_max.isnull() ? Index(t_max_default.pos()) : Group::Index(t_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord psdWangEtAl16(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& t_min={},

               const Var::Numeric& t_max={},

               const Var::Index& picky={}) {

  if (not t_min.isnull() and t_min.islast()) {

    throw std::runtime_error("t_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdWangEtAl16");

  } if (not t_max.isnull() and t_max.islast()) {

    throw std::runtime_error("t_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to psdWangEtAl16");

  } if (not picky.isnull() and picky.islast()) {

    throw std::runtime_error("picky needs to be a defined WorkspaceIndex (or left default) since it is agenda input to psdWangEtAl16");

  }


  static const auto t_min_default = Var::NumericCreate(ws, 273,

    "psdWangEtAl16_t_min_autodefault",

    "auto generated variable with default from method definition");

  static const auto t_max_default = Var::NumericCreate(ws, 373,

    "psdWangEtAl16_t_max_autodefault",

    "auto generated variable with default from method definition");

  static const auto picky_default = Var::IndexCreate(ws, 0,

    "psdWangEtAl16_picky_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1202,

    Group::ArrayOfIndex({240, 77, }),

    Group::ArrayOfIndex({241, 209, 208, 211, 74, 278, 279, t_min.isnull() ? Index(t_min_default.pos()) : Group::Index(t_min.pos()), t_max.isnull() ? Index(t_max_default.pos()) : Group::Index(t_max.pos()), picky.isnull() ? Index(picky_default.pos()) : Group::Index(picky.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord p_gridDensify(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector p_grid_old,

               const Var::Index& nfill={}) {

  if (p_grid_old.islast()) {

    throw std::runtime_error("p_grid_old needs to be a defined WorkspaceVector since it is agenda input to p_gridDensify");

  } if (not nfill.isnull() and nfill.islast()) {

    throw std::runtime_error("nfill needs to be a defined WorkspaceIndex (or left default) since it is agenda input to p_gridDensify");

  }


  static const auto nfill_default = Var::IndexCreate(ws, -1,

    "p_gridDensify_nfill_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1203,

    Group::ArrayOfIndex({242, 36, 37, 48, }),

    Group::ArrayOfIndex({Group::Index(p_grid_old.pos()), nfill.isnull() ? Index(nfill_default.pos()) : Group::Index(nfill.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord p_gridFromZRaw(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& no_negZ={}) {

  if (not no_negZ.isnull() and no_negZ.islast()) {

    throw std::runtime_error("no_negZ needs to be a defined WorkspaceIndex (or left default) since it is agenda input to p_gridFromZRaw");

  }


  static const auto no_negZ_default = Var::IndexCreate(ws, 1,

    "p_gridFromZRaw_no_negZ_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1204,

    Group::ArrayOfIndex({242, }),

    Group::ArrayOfIndex({382, no_negZ.isnull() ? Index(no_negZ_default.pos()) : Group::Index(no_negZ.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord lat_gridFromZRaw(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1205,

    Group::ArrayOfIndex({139, }),

    Group::ArrayOfIndex({382, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord lon_gridFromZRaw(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1206,

    Group::ArrayOfIndex({147, }),

    Group::ArrayOfIndex({382, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord atm_gridsFromZRaw(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& no_negZ={}) {

  if (not no_negZ.isnull() and no_negZ.islast()) {

    throw std::runtime_error("no_negZ needs to be a defined WorkspaceIndex (or left default) since it is agenda input to atm_gridsFromZRaw");

  }


  static const auto no_negZ_default = Var::IndexCreate(ws, 1,

    "atm_gridsFromZRaw_no_negZ_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1207,

    Group::ArrayOfIndex({242, 139, 147, }),

    Group::ArrayOfIndex({382, no_negZ.isnull() ? Index(no_negZ_default.pos()) : Group::Index(no_negZ.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord p_gridFromGasAbsLookup(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1208,

    Group::ArrayOfIndex({242, }),

    Group::ArrayOfIndex({12, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord p_gridRefine(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector p_grid_old,

               const Var::Numeric p_step) {

  if (p_grid_old.islast()) {

    throw std::runtime_error("p_grid_old needs to be a defined WorkspaceVector since it is agenda input to p_gridRefine");

  } if (p_step.islast()) {

    throw std::runtime_error("p_step needs to be a defined WorkspaceNumeric since it is agenda input to p_gridRefine");

  }


  return MRecord(1209,

    Group::ArrayOfIndex({242, 36, 37, 48, }),

    Group::ArrayOfIndex({Group::Index(p_grid_old.pos()), Group::Index(p_step.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord RadiationFieldSpectralIntegrate(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 radiation_field,

               const Var::Tensor5 spectral_radiation_field) {

  if (radiation_field.islast()) {

    throw std::runtime_error("radiation_field needs to be a defined WorkspaceTensor4 since it is output of RadiationFieldSpectralIntegrate");

  } if (spectral_radiation_field.islast()) {

    throw std::runtime_error("spectral_radiation_field needs to be a defined WorkspaceTensor5 since it is agenda input to RadiationFieldSpectralIntegrate");

  }


  return MRecord(1210,

    Group::ArrayOfIndex({Group::Index(radiation_field.pos()), }),

    Group::ArrayOfIndex({104, Group::Index(spectral_radiation_field.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord RadiationFieldSpectralIntegrate(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor5 radiation_field,

               const Var::Tensor7 spectral_radiation_field) {

  if (radiation_field.islast()) {

    throw std::runtime_error("radiation_field needs to be a defined WorkspaceTensor5 since it is output of RadiationFieldSpectralIntegrate");

  } if (spectral_radiation_field.islast()) {

    throw std::runtime_error("spectral_radiation_field needs to be a defined WorkspaceTensor7 since it is agenda input to RadiationFieldSpectralIntegrate");

  }


  return MRecord(1211,

    Group::ArrayOfIndex({Group::Index(radiation_field.pos()), }),

    Group::ArrayOfIndex({104, Group::Index(spectral_radiation_field.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord line_irradianceCalcForSingleSpeciesNonOverlappingLinesPseudo2D(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric df,

               const Var::Index nz,

               const Var::Index nf,

               const Var::Numeric& r={}) {

  if (df.islast()) {

    throw std::runtime_error("df needs to be a defined WorkspaceNumeric since it is agenda input to line_irradianceCalcForSingleSpeciesNonOverlappingLinesPseudo2D");

  } if (nz.islast()) {

    throw std::runtime_error("nz needs to be a defined WorkspaceIndex since it is agenda input to line_irradianceCalcForSingleSpeciesNonOverlappingLinesPseudo2D");

  } if (nf.islast()) {

    throw std::runtime_error("nf needs to be a defined WorkspaceIndex since it is agenda input to line_irradianceCalcForSingleSpeciesNonOverlappingLinesPseudo2D");

  } if (not r.isnull() and r.islast()) {

    throw std::runtime_error("r needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to line_irradianceCalcForSingleSpeciesNonOverlappingLinesPseudo2D");

  }


  static const auto r_default = Var::NumericCreate(ws, 1.0,

    "line_irradianceCalcForSingleSpeciesNonOverlappingLinesPseudo2D_r_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1212,

    Group::ArrayOfIndex({142, 143, }),

    Group::ArrayOfIndex({21, 11, 339, 344, 338, 381, 242, 250, 315, 127, 217, 128, 129, 123, 238, Group::Index(df.pos()), Group::Index(nz.pos()), Group::Index(nf.pos()), r.isnull() ? Index(r_default.pos()) : Group::Index(r.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord RationalAdd(

    [[maybe_unused]] Workspace& ws,

                     Var::Rational out,

               const Var::Rational in,

               const Var::Rational value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRational since it is output of RationalAdd");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRational since it is agenda input to RationalAdd");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceRational since it is agenda input to RationalAdd");

  }


  return MRecord(1213,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord RationalInvScale(

    [[maybe_unused]] Workspace& ws,

                     Var::Rational out,

               const Var::Rational in,

               const Var::Rational value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRational since it is output of RationalInvScale");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRational since it is agenda input to RationalInvScale");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceRational since it is agenda input to RationalInvScale");

  }


  return MRecord(1214,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord RationalScale(

    [[maybe_unused]] Workspace& ws,

                     Var::Rational out,

               const Var::Rational in,

               const Var::Rational value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRational since it is output of RationalScale");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRational since it is agenda input to RationalScale");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceRational since it is agenda input to RationalScale");

  }


  return MRecord(1215,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord RationalSet(

    [[maybe_unused]] Workspace& ws,

                     Var::Rational out,

               const Var::Index numerator,

               const Var::Index& denominator={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRational since it is output of RationalSet");

  } if (numerator.islast()) {

    throw std::runtime_error("numerator needs to be a defined WorkspaceIndex since it is agenda input to RationalSet");

  } if (not denominator.isnull() and denominator.islast()) {

    throw std::runtime_error("denominator needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RationalSet");

  }


  static const auto denominator_default = Var::IndexCreate(ws, 1,

    "RationalSet_denominator_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1216,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(numerator.pos()), denominator.isnull() ? Index(denominator_default.pos()) : Group::Index(denominator.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadArrayOfARTSCAT(

    [[maybe_unused]] Workspace& ws,

               const Var::String filename,

               const Var::Numeric& fmin={},

               const Var::Numeric& fmax={},

               const Var::String& globalquantumnumbers={},

               const Var::String& localquantumnumbers={},

               const Var::String& normalization_option={},

               const Var::String& mirroring_option={},

               const Var::String& population_option={},

               const Var::String& lineshapetype_option={},

               const Var::String& cutoff_option={},

               const Var::Numeric& cutoff_value={},

               const Var::Numeric& linemixinglimit_value={}) {

  if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to ReadArrayOfARTSCAT");

  } if (not fmin.isnull() and fmin.islast()) {

    throw std::runtime_error("fmin needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadArrayOfARTSCAT");

  } if (not fmax.isnull() and fmax.islast()) {

    throw std::runtime_error("fmax needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadArrayOfARTSCAT");

  } if (not globalquantumnumbers.isnull() and globalquantumnumbers.islast()) {

    throw std::runtime_error("globalquantumnumbers needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadArrayOfARTSCAT");

  } if (not localquantumnumbers.isnull() and localquantumnumbers.islast()) {

    throw std::runtime_error("localquantumnumbers needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadArrayOfARTSCAT");

  } if (not normalization_option.isnull() and normalization_option.islast()) {

    throw std::runtime_error("normalization_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadArrayOfARTSCAT");

  } if (not mirroring_option.isnull() and mirroring_option.islast()) {

    throw std::runtime_error("mirroring_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadArrayOfARTSCAT");

  } if (not population_option.isnull() and population_option.islast()) {

    throw std::runtime_error("population_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadArrayOfARTSCAT");

  } if (not lineshapetype_option.isnull() and lineshapetype_option.islast()) {

    throw std::runtime_error("lineshapetype_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadArrayOfARTSCAT");

  } if (not cutoff_option.isnull() and cutoff_option.islast()) {

    throw std::runtime_error("cutoff_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadArrayOfARTSCAT");

  } if (not cutoff_value.isnull() and cutoff_value.islast()) {

    throw std::runtime_error("cutoff_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadArrayOfARTSCAT");

  } if (not linemixinglimit_value.isnull() and linemixinglimit_value.islast()) {

    throw std::runtime_error("linemixinglimit_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadArrayOfARTSCAT");

  }


  static const auto fmin_default = Var::NumericCreate(ws, 0,

    "ReadArrayOfARTSCAT_fmin_autodefault",

    "auto generated variable with default from method definition");

  static const auto fmax_default = Var::NumericCreate(ws, 1e99,

    "ReadArrayOfARTSCAT_fmax_autodefault",

    "auto generated variable with default from method definition");

  static const auto globalquantumnumbers_default = Var::StringCreate(ws, "",

    "ReadArrayOfARTSCAT_globalquantumnumbers_autodefault",

    "auto generated variable with default from method definition");

  static const auto localquantumnumbers_default = Var::StringCreate(ws, "",

    "ReadArrayOfARTSCAT_localquantumnumbers_autodefault",

    "auto generated variable with default from method definition");

  static const auto normalization_option_default = Var::StringCreate(ws, "None",

    "ReadArrayOfARTSCAT_normalization_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto mirroring_option_default = Var::StringCreate(ws, "None",

    "ReadArrayOfARTSCAT_mirroring_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto population_option_default = Var::StringCreate(ws, "LTE",

    "ReadArrayOfARTSCAT_population_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto lineshapetype_option_default = Var::StringCreate(ws, "VP",

    "ReadArrayOfARTSCAT_lineshapetype_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto cutoff_option_default = Var::StringCreate(ws, "None",

    "ReadArrayOfARTSCAT_cutoff_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto cutoff_value_default = Var::NumericCreate(ws, 750e9,

    "ReadArrayOfARTSCAT_cutoff_value_autodefault",

    "auto generated variable with default from method definition");

  static const auto linemixinglimit_value_default = Var::NumericCreate(ws, -1,

    "ReadArrayOfARTSCAT_linemixinglimit_value_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1217,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), fmin.isnull() ? Index(fmin_default.pos()) : Group::Index(fmin.pos()), fmax.isnull() ? Index(fmax_default.pos()) : Group::Index(fmax.pos()), globalquantumnumbers.isnull() ? Index(globalquantumnumbers_default.pos()) : Group::Index(globalquantumnumbers.pos()), localquantumnumbers.isnull() ? Index(localquantumnumbers_default.pos()) : Group::Index(localquantumnumbers.pos()), normalization_option.isnull() ? Index(normalization_option_default.pos()) : Group::Index(normalization_option.pos()), mirroring_option.isnull() ? Index(mirroring_option_default.pos()) : Group::Index(mirroring_option.pos()), population_option.isnull() ? Index(population_option_default.pos()) : Group::Index(population_option.pos()), lineshapetype_option.isnull() ? Index(lineshapetype_option_default.pos()) : Group::Index(lineshapetype_option.pos()), cutoff_option.isnull() ? Index(cutoff_option_default.pos()) : Group::Index(cutoff_option.pos()), cutoff_value.isnull() ? Index(cutoff_value_default.pos()) : Group::Index(cutoff_value.pos()), linemixinglimit_value.isnull() ? Index(linemixinglimit_value_default.pos()) : Group::Index(linemixinglimit_value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadSplitARTSCAT(

    [[maybe_unused]] Workspace& ws,

               const Var::String basename,

               const Var::Numeric& fmin={},

               const Var::Numeric& fmax={},

               const Var::String& globalquantumnumbers={},

               const Var::String& localquantumnumbers={},

               const Var::Index& ignore_missing={},

               const Var::String& normalization_option={},

               const Var::String& mirroring_option={},

               const Var::String& population_option={},

               const Var::String& lineshapetype_option={},

               const Var::String& cutoff_option={},

               const Var::Numeric& cutoff_value={},

               const Var::Numeric& linemixinglimit_value={}) {

  if (basename.islast()) {

    throw std::runtime_error("basename needs to be a defined WorkspaceString since it is agenda input to ReadSplitARTSCAT");

  } if (not fmin.isnull() and fmin.islast()) {

    throw std::runtime_error("fmin needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadSplitARTSCAT");

  } if (not fmax.isnull() and fmax.islast()) {

    throw std::runtime_error("fmax needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadSplitARTSCAT");

  } if (not globalquantumnumbers.isnull() and globalquantumnumbers.islast()) {

    throw std::runtime_error("globalquantumnumbers needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadSplitARTSCAT");

  } if (not localquantumnumbers.isnull() and localquantumnumbers.islast()) {

    throw std::runtime_error("localquantumnumbers needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadSplitARTSCAT");

  } if (not ignore_missing.isnull() and ignore_missing.islast()) {

    throw std::runtime_error("ignore_missing needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadSplitARTSCAT");

  } if (not normalization_option.isnull() and normalization_option.islast()) {

    throw std::runtime_error("normalization_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadSplitARTSCAT");

  } if (not mirroring_option.isnull() and mirroring_option.islast()) {

    throw std::runtime_error("mirroring_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadSplitARTSCAT");

  } if (not population_option.isnull() and population_option.islast()) {

    throw std::runtime_error("population_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadSplitARTSCAT");

  } if (not lineshapetype_option.isnull() and lineshapetype_option.islast()) {

    throw std::runtime_error("lineshapetype_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadSplitARTSCAT");

  } if (not cutoff_option.isnull() and cutoff_option.islast()) {

    throw std::runtime_error("cutoff_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadSplitARTSCAT");

  } if (not cutoff_value.isnull() and cutoff_value.islast()) {

    throw std::runtime_error("cutoff_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadSplitARTSCAT");

  } if (not linemixinglimit_value.isnull() and linemixinglimit_value.islast()) {

    throw std::runtime_error("linemixinglimit_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadSplitARTSCAT");

  }


  static const auto fmin_default = Var::NumericCreate(ws, 0,

    "ReadSplitARTSCAT_fmin_autodefault",

    "auto generated variable with default from method definition");

  static const auto fmax_default = Var::NumericCreate(ws, 1e99,

    "ReadSplitARTSCAT_fmax_autodefault",

    "auto generated variable with default from method definition");

  static const auto globalquantumnumbers_default = Var::StringCreate(ws, "",

    "ReadSplitARTSCAT_globalquantumnumbers_autodefault",

    "auto generated variable with default from method definition");

  static const auto localquantumnumbers_default = Var::StringCreate(ws, "",

    "ReadSplitARTSCAT_localquantumnumbers_autodefault",

    "auto generated variable with default from method definition");

  static const auto ignore_missing_default = Var::IndexCreate(ws, 0,

    "ReadSplitARTSCAT_ignore_missing_autodefault",

    "auto generated variable with default from method definition");

  static const auto normalization_option_default = Var::StringCreate(ws, "None",

    "ReadSplitARTSCAT_normalization_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto mirroring_option_default = Var::StringCreate(ws, "None",

    "ReadSplitARTSCAT_mirroring_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto population_option_default = Var::StringCreate(ws, "LTE",

    "ReadSplitARTSCAT_population_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto lineshapetype_option_default = Var::StringCreate(ws, "VP",

    "ReadSplitARTSCAT_lineshapetype_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto cutoff_option_default = Var::StringCreate(ws, "None",

    "ReadSplitARTSCAT_cutoff_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto cutoff_value_default = Var::NumericCreate(ws, 750e9,

    "ReadSplitARTSCAT_cutoff_value_autodefault",

    "auto generated variable with default from method definition");

  static const auto linemixinglimit_value_default = Var::NumericCreate(ws, -1,

    "ReadSplitARTSCAT_linemixinglimit_value_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1218,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({21, Group::Index(basename.pos()), fmin.isnull() ? Index(fmin_default.pos()) : Group::Index(fmin.pos()), fmax.isnull() ? Index(fmax_default.pos()) : Group::Index(fmax.pos()), globalquantumnumbers.isnull() ? Index(globalquantumnumbers_default.pos()) : Group::Index(globalquantumnumbers.pos()), localquantumnumbers.isnull() ? Index(localquantumnumbers_default.pos()) : Group::Index(localquantumnumbers.pos()), ignore_missing.isnull() ? Index(ignore_missing_default.pos()) : Group::Index(ignore_missing.pos()), normalization_option.isnull() ? Index(normalization_option_default.pos()) : Group::Index(normalization_option.pos()), mirroring_option.isnull() ? Index(mirroring_option_default.pos()) : Group::Index(mirroring_option.pos()), population_option.isnull() ? Index(population_option_default.pos()) : Group::Index(population_option.pos()), lineshapetype_option.isnull() ? Index(lineshapetype_option_default.pos()) : Group::Index(lineshapetype_option.pos()), cutoff_option.isnull() ? Index(cutoff_option_default.pos()) : Group::Index(cutoff_option.pos()), cutoff_value.isnull() ? Index(cutoff_value_default.pos()) : Group::Index(cutoff_value.pos()), linemixinglimit_value.isnull() ? Index(linemixinglimit_value_default.pos()) : Group::Index(linemixinglimit_value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadARTSCAT(

    [[maybe_unused]] Workspace& ws,

               const Var::String filename,

               const Var::Numeric& fmin={},

               const Var::Numeric& fmax={},

               const Var::String& globalquantumnumbers={},

               const Var::String& localquantumnumbers={},

               const Var::String& normalization_option={},

               const Var::String& mirroring_option={},

               const Var::String& population_option={},

               const Var::String& lineshapetype_option={},

               const Var::String& cutoff_option={},

               const Var::Numeric& cutoff_value={},

               const Var::Numeric& linemixinglimit_value={}) {

  if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to ReadARTSCAT");

  } if (not fmin.isnull() and fmin.islast()) {

    throw std::runtime_error("fmin needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadARTSCAT");

  } if (not fmax.isnull() and fmax.islast()) {

    throw std::runtime_error("fmax needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadARTSCAT");

  } if (not globalquantumnumbers.isnull() and globalquantumnumbers.islast()) {

    throw std::runtime_error("globalquantumnumbers needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadARTSCAT");

  } if (not localquantumnumbers.isnull() and localquantumnumbers.islast()) {

    throw std::runtime_error("localquantumnumbers needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadARTSCAT");

  } if (not normalization_option.isnull() and normalization_option.islast()) {

    throw std::runtime_error("normalization_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadARTSCAT");

  } if (not mirroring_option.isnull() and mirroring_option.islast()) {

    throw std::runtime_error("mirroring_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadARTSCAT");

  } if (not population_option.isnull() and population_option.islast()) {

    throw std::runtime_error("population_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadARTSCAT");

  } if (not lineshapetype_option.isnull() and lineshapetype_option.islast()) {

    throw std::runtime_error("lineshapetype_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadARTSCAT");

  } if (not cutoff_option.isnull() and cutoff_option.islast()) {

    throw std::runtime_error("cutoff_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadARTSCAT");

  } if (not cutoff_value.isnull() and cutoff_value.islast()) {

    throw std::runtime_error("cutoff_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadARTSCAT");

  } if (not linemixinglimit_value.isnull() and linemixinglimit_value.islast()) {

    throw std::runtime_error("linemixinglimit_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadARTSCAT");

  }


  static const auto fmin_default = Var::NumericCreate(ws, 0,

    "ReadARTSCAT_fmin_autodefault",

    "auto generated variable with default from method definition");

  static const auto fmax_default = Var::NumericCreate(ws, 1e99,

    "ReadARTSCAT_fmax_autodefault",

    "auto generated variable with default from method definition");

  static const auto globalquantumnumbers_default = Var::StringCreate(ws, "",

    "ReadARTSCAT_globalquantumnumbers_autodefault",

    "auto generated variable with default from method definition");

  static const auto localquantumnumbers_default = Var::StringCreate(ws, "",

    "ReadARTSCAT_localquantumnumbers_autodefault",

    "auto generated variable with default from method definition");

  static const auto normalization_option_default = Var::StringCreate(ws, "None",

    "ReadARTSCAT_normalization_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto mirroring_option_default = Var::StringCreate(ws, "None",

    "ReadARTSCAT_mirroring_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto population_option_default = Var::StringCreate(ws, "LTE",

    "ReadARTSCAT_population_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto lineshapetype_option_default = Var::StringCreate(ws, "VP",

    "ReadARTSCAT_lineshapetype_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto cutoff_option_default = Var::StringCreate(ws, "None",

    "ReadARTSCAT_cutoff_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto cutoff_value_default = Var::NumericCreate(ws, 750e9,

    "ReadARTSCAT_cutoff_value_autodefault",

    "auto generated variable with default from method definition");

  static const auto linemixinglimit_value_default = Var::NumericCreate(ws, -1,

    "ReadARTSCAT_linemixinglimit_value_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1219,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), fmin.isnull() ? Index(fmin_default.pos()) : Group::Index(fmin.pos()), fmax.isnull() ? Index(fmax_default.pos()) : Group::Index(fmax.pos()), globalquantumnumbers.isnull() ? Index(globalquantumnumbers_default.pos()) : Group::Index(globalquantumnumbers.pos()), localquantumnumbers.isnull() ? Index(localquantumnumbers_default.pos()) : Group::Index(localquantumnumbers.pos()), normalization_option.isnull() ? Index(normalization_option_default.pos()) : Group::Index(normalization_option.pos()), mirroring_option.isnull() ? Index(mirroring_option_default.pos()) : Group::Index(mirroring_option.pos()), population_option.isnull() ? Index(population_option_default.pos()) : Group::Index(population_option.pos()), lineshapetype_option.isnull() ? Index(lineshapetype_option_default.pos()) : Group::Index(lineshapetype_option.pos()), cutoff_option.isnull() ? Index(cutoff_option_default.pos()) : Group::Index(cutoff_option.pos()), cutoff_value.isnull() ? Index(cutoff_value_default.pos()) : Group::Index(cutoff_value.pos()), linemixinglimit_value.isnull() ? Index(linemixinglimit_value_default.pos()) : Group::Index(linemixinglimit_value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadHITRAN(

    [[maybe_unused]] Workspace& ws,

               const Var::String filename,

               const Var::Numeric& fmin={},

               const Var::Numeric& fmax={},

               const Var::String& globalquantumnumbers={},

               const Var::String& localquantumnumbers={},

               const Var::String& hitran_type={},

               const Var::String& normalization_option={},

               const Var::String& mirroring_option={},

               const Var::String& population_option={},

               const Var::String& lineshapetype_option={},

               const Var::String& cutoff_option={},

               const Var::Numeric& cutoff_value={},

               const Var::Numeric& linemixinglimit_value={}) {

  if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to ReadHITRAN");

  } if (not fmin.isnull() and fmin.islast()) {

    throw std::runtime_error("fmin needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadHITRAN");

  } if (not fmax.isnull() and fmax.islast()) {

    throw std::runtime_error("fmax needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadHITRAN");

  } if (not globalquantumnumbers.isnull() and globalquantumnumbers.islast()) {

    throw std::runtime_error("globalquantumnumbers needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadHITRAN");

  } if (not localquantumnumbers.isnull() and localquantumnumbers.islast()) {

    throw std::runtime_error("localquantumnumbers needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadHITRAN");

  } if (not hitran_type.isnull() and hitran_type.islast()) {

    throw std::runtime_error("hitran_type needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadHITRAN");

  } if (not normalization_option.isnull() and normalization_option.islast()) {

    throw std::runtime_error("normalization_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadHITRAN");

  } if (not mirroring_option.isnull() and mirroring_option.islast()) {

    throw std::runtime_error("mirroring_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadHITRAN");

  } if (not population_option.isnull() and population_option.islast()) {

    throw std::runtime_error("population_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadHITRAN");

  } if (not lineshapetype_option.isnull() and lineshapetype_option.islast()) {

    throw std::runtime_error("lineshapetype_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadHITRAN");

  } if (not cutoff_option.isnull() and cutoff_option.islast()) {

    throw std::runtime_error("cutoff_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadHITRAN");

  } if (not cutoff_value.isnull() and cutoff_value.islast()) {

    throw std::runtime_error("cutoff_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadHITRAN");

  } if (not linemixinglimit_value.isnull() and linemixinglimit_value.islast()) {

    throw std::runtime_error("linemixinglimit_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadHITRAN");

  }


  static const auto fmin_default = Var::NumericCreate(ws, 0,

    "ReadHITRAN_fmin_autodefault",

    "auto generated variable with default from method definition");

  static const auto fmax_default = Var::NumericCreate(ws, 1e99,

    "ReadHITRAN_fmax_autodefault",

    "auto generated variable with default from method definition");

  static const auto globalquantumnumbers_default = Var::StringCreate(ws, "",

    "ReadHITRAN_globalquantumnumbers_autodefault",

    "auto generated variable with default from method definition");

  static const auto localquantumnumbers_default = Var::StringCreate(ws, "",

    "ReadHITRAN_localquantumnumbers_autodefault",

    "auto generated variable with default from method definition");

  static const auto hitran_type_default = Var::StringCreate(ws, "Post2004",

    "ReadHITRAN_hitran_type_autodefault",

    "auto generated variable with default from method definition");

  static const auto normalization_option_default = Var::StringCreate(ws, "None",

    "ReadHITRAN_normalization_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto mirroring_option_default = Var::StringCreate(ws, "None",

    "ReadHITRAN_mirroring_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto population_option_default = Var::StringCreate(ws, "LTE",

    "ReadHITRAN_population_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto lineshapetype_option_default = Var::StringCreate(ws, "VP",

    "ReadHITRAN_lineshapetype_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto cutoff_option_default = Var::StringCreate(ws, "None",

    "ReadHITRAN_cutoff_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto cutoff_value_default = Var::NumericCreate(ws, 750e9,

    "ReadHITRAN_cutoff_value_autodefault",

    "auto generated variable with default from method definition");

  static const auto linemixinglimit_value_default = Var::NumericCreate(ws, -1,

    "ReadHITRAN_linemixinglimit_value_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1220,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), fmin.isnull() ? Index(fmin_default.pos()) : Group::Index(fmin.pos()), fmax.isnull() ? Index(fmax_default.pos()) : Group::Index(fmax.pos()), globalquantumnumbers.isnull() ? Index(globalquantumnumbers_default.pos()) : Group::Index(globalquantumnumbers.pos()), localquantumnumbers.isnull() ? Index(localquantumnumbers_default.pos()) : Group::Index(localquantumnumbers.pos()), hitran_type.isnull() ? Index(hitran_type_default.pos()) : Group::Index(hitran_type.pos()), normalization_option.isnull() ? Index(normalization_option_default.pos()) : Group::Index(normalization_option.pos()), mirroring_option.isnull() ? Index(mirroring_option_default.pos()) : Group::Index(mirroring_option.pos()), population_option.isnull() ? Index(population_option_default.pos()) : Group::Index(population_option.pos()), lineshapetype_option.isnull() ? Index(lineshapetype_option_default.pos()) : Group::Index(lineshapetype_option.pos()), cutoff_option.isnull() ? Index(cutoff_option_default.pos()) : Group::Index(cutoff_option.pos()), cutoff_value.isnull() ? Index(cutoff_value_default.pos()) : Group::Index(cutoff_value.pos()), linemixinglimit_value.isnull() ? Index(linemixinglimit_value_default.pos()) : Group::Index(linemixinglimit_value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadLBLRTM(

    [[maybe_unused]] Workspace& ws,

               const Var::String filename,

               const Var::Numeric& fmin={},

               const Var::Numeric& fmax={},

               const Var::String& globalquantumnumbers={},

               const Var::String& localquantumnumbers={},

               const Var::String& normalization_option={},

               const Var::String& mirroring_option={},

               const Var::String& population_option={},

               const Var::String& lineshapetype_option={},

               const Var::String& cutoff_option={},

               const Var::Numeric& cutoff_value={},

               const Var::Numeric& linemixinglimit_value={}) {

  if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to ReadLBLRTM");

  } if (not fmin.isnull() and fmin.islast()) {

    throw std::runtime_error("fmin needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadLBLRTM");

  } if (not fmax.isnull() and fmax.islast()) {

    throw std::runtime_error("fmax needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadLBLRTM");

  } if (not globalquantumnumbers.isnull() and globalquantumnumbers.islast()) {

    throw std::runtime_error("globalquantumnumbers needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadLBLRTM");

  } if (not localquantumnumbers.isnull() and localquantumnumbers.islast()) {

    throw std::runtime_error("localquantumnumbers needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadLBLRTM");

  } if (not normalization_option.isnull() and normalization_option.islast()) {

    throw std::runtime_error("normalization_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadLBLRTM");

  } if (not mirroring_option.isnull() and mirroring_option.islast()) {

    throw std::runtime_error("mirroring_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadLBLRTM");

  } if (not population_option.isnull() and population_option.islast()) {

    throw std::runtime_error("population_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadLBLRTM");

  } if (not lineshapetype_option.isnull() and lineshapetype_option.islast()) {

    throw std::runtime_error("lineshapetype_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadLBLRTM");

  } if (not cutoff_option.isnull() and cutoff_option.islast()) {

    throw std::runtime_error("cutoff_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadLBLRTM");

  } if (not cutoff_value.isnull() and cutoff_value.islast()) {

    throw std::runtime_error("cutoff_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadLBLRTM");

  } if (not linemixinglimit_value.isnull() and linemixinglimit_value.islast()) {

    throw std::runtime_error("linemixinglimit_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadLBLRTM");

  }


  static const auto fmin_default = Var::NumericCreate(ws, 0,

    "ReadLBLRTM_fmin_autodefault",

    "auto generated variable with default from method definition");

  static const auto fmax_default = Var::NumericCreate(ws, 1e99,

    "ReadLBLRTM_fmax_autodefault",

    "auto generated variable with default from method definition");

  static const auto globalquantumnumbers_default = Var::StringCreate(ws, "",

    "ReadLBLRTM_globalquantumnumbers_autodefault",

    "auto generated variable with default from method definition");

  static const auto localquantumnumbers_default = Var::StringCreate(ws, "",

    "ReadLBLRTM_localquantumnumbers_autodefault",

    "auto generated variable with default from method definition");

  static const auto normalization_option_default = Var::StringCreate(ws, "None",

    "ReadLBLRTM_normalization_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto mirroring_option_default = Var::StringCreate(ws, "None",

    "ReadLBLRTM_mirroring_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto population_option_default = Var::StringCreate(ws, "LTE",

    "ReadLBLRTM_population_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto lineshapetype_option_default = Var::StringCreate(ws, "VP",

    "ReadLBLRTM_lineshapetype_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto cutoff_option_default = Var::StringCreate(ws, "None",

    "ReadLBLRTM_cutoff_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto cutoff_value_default = Var::NumericCreate(ws, 750e9,

    "ReadLBLRTM_cutoff_value_autodefault",

    "auto generated variable with default from method definition");

  static const auto linemixinglimit_value_default = Var::NumericCreate(ws, -1,

    "ReadLBLRTM_linemixinglimit_value_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1221,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), fmin.isnull() ? Index(fmin_default.pos()) : Group::Index(fmin.pos()), fmax.isnull() ? Index(fmax_default.pos()) : Group::Index(fmax.pos()), globalquantumnumbers.isnull() ? Index(globalquantumnumbers_default.pos()) : Group::Index(globalquantumnumbers.pos()), localquantumnumbers.isnull() ? Index(localquantumnumbers_default.pos()) : Group::Index(localquantumnumbers.pos()), normalization_option.isnull() ? Index(normalization_option_default.pos()) : Group::Index(normalization_option.pos()), mirroring_option.isnull() ? Index(mirroring_option_default.pos()) : Group::Index(mirroring_option.pos()), population_option.isnull() ? Index(population_option_default.pos()) : Group::Index(population_option.pos()), lineshapetype_option.isnull() ? Index(lineshapetype_option_default.pos()) : Group::Index(lineshapetype_option.pos()), cutoff_option.isnull() ? Index(cutoff_option_default.pos()) : Group::Index(cutoff_option.pos()), cutoff_value.isnull() ? Index(cutoff_value_default.pos()) : Group::Index(cutoff_value.pos()), linemixinglimit_value.isnull() ? Index(linemixinglimit_value_default.pos()) : Group::Index(linemixinglimit_value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadMytran2(

    [[maybe_unused]] Workspace& ws,

               const Var::String filename,

               const Var::Numeric& fmin={},

               const Var::Numeric& fmax={},

               const Var::String& globalquantumnumbers={},

               const Var::String& localquantumnumbers={},

               const Var::String& normalization_option={},

               const Var::String& mirroring_option={},

               const Var::String& population_option={},

               const Var::String& lineshapetype_option={},

               const Var::String& cutoff_option={},

               const Var::Numeric& cutoff_value={},

               const Var::Numeric& linemixinglimit_value={}) {

  if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to ReadMytran2");

  } if (not fmin.isnull() and fmin.islast()) {

    throw std::runtime_error("fmin needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadMytran2");

  } if (not fmax.isnull() and fmax.islast()) {

    throw std::runtime_error("fmax needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadMytran2");

  } if (not globalquantumnumbers.isnull() and globalquantumnumbers.islast()) {

    throw std::runtime_error("globalquantumnumbers needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadMytran2");

  } if (not localquantumnumbers.isnull() and localquantumnumbers.islast()) {

    throw std::runtime_error("localquantumnumbers needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadMytran2");

  } if (not normalization_option.isnull() and normalization_option.islast()) {

    throw std::runtime_error("normalization_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadMytran2");

  } if (not mirroring_option.isnull() and mirroring_option.islast()) {

    throw std::runtime_error("mirroring_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadMytran2");

  } if (not population_option.isnull() and population_option.islast()) {

    throw std::runtime_error("population_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadMytran2");

  } if (not lineshapetype_option.isnull() and lineshapetype_option.islast()) {

    throw std::runtime_error("lineshapetype_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadMytran2");

  } if (not cutoff_option.isnull() and cutoff_option.islast()) {

    throw std::runtime_error("cutoff_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadMytran2");

  } if (not cutoff_value.isnull() and cutoff_value.islast()) {

    throw std::runtime_error("cutoff_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadMytran2");

  } if (not linemixinglimit_value.isnull() and linemixinglimit_value.islast()) {

    throw std::runtime_error("linemixinglimit_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadMytran2");

  }


  static const auto fmin_default = Var::NumericCreate(ws, 0,

    "ReadMytran2_fmin_autodefault",

    "auto generated variable with default from method definition");

  static const auto fmax_default = Var::NumericCreate(ws, 1e99,

    "ReadMytran2_fmax_autodefault",

    "auto generated variable with default from method definition");

  static const auto globalquantumnumbers_default = Var::StringCreate(ws, "",

    "ReadMytran2_globalquantumnumbers_autodefault",

    "auto generated variable with default from method definition");

  static const auto localquantumnumbers_default = Var::StringCreate(ws, "",

    "ReadMytran2_localquantumnumbers_autodefault",

    "auto generated variable with default from method definition");

  static const auto normalization_option_default = Var::StringCreate(ws, "None",

    "ReadMytran2_normalization_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto mirroring_option_default = Var::StringCreate(ws, "None",

    "ReadMytran2_mirroring_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto population_option_default = Var::StringCreate(ws, "LTE",

    "ReadMytran2_population_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto lineshapetype_option_default = Var::StringCreate(ws, "VP",

    "ReadMytran2_lineshapetype_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto cutoff_option_default = Var::StringCreate(ws, "None",

    "ReadMytran2_cutoff_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto cutoff_value_default = Var::NumericCreate(ws, 750e9,

    "ReadMytran2_cutoff_value_autodefault",

    "auto generated variable with default from method definition");

  static const auto linemixinglimit_value_default = Var::NumericCreate(ws, -1,

    "ReadMytran2_linemixinglimit_value_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1222,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), fmin.isnull() ? Index(fmin_default.pos()) : Group::Index(fmin.pos()), fmax.isnull() ? Index(fmax_default.pos()) : Group::Index(fmax.pos()), globalquantumnumbers.isnull() ? Index(globalquantumnumbers_default.pos()) : Group::Index(globalquantumnumbers.pos()), localquantumnumbers.isnull() ? Index(localquantumnumbers_default.pos()) : Group::Index(localquantumnumbers.pos()), normalization_option.isnull() ? Index(normalization_option_default.pos()) : Group::Index(normalization_option.pos()), mirroring_option.isnull() ? Index(mirroring_option_default.pos()) : Group::Index(mirroring_option.pos()), population_option.isnull() ? Index(population_option_default.pos()) : Group::Index(population_option.pos()), lineshapetype_option.isnull() ? Index(lineshapetype_option_default.pos()) : Group::Index(lineshapetype_option.pos()), cutoff_option.isnull() ? Index(cutoff_option_default.pos()) : Group::Index(cutoff_option.pos()), cutoff_value.isnull() ? Index(cutoff_value_default.pos()) : Group::Index(cutoff_value.pos()), linemixinglimit_value.isnull() ? Index(linemixinglimit_value_default.pos()) : Group::Index(linemixinglimit_value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadJPL(

    [[maybe_unused]] Workspace& ws,

               const Var::String filename,

               const Var::Numeric& fmin={},

               const Var::Numeric& fmax={},

               const Var::String& globalquantumnumbers={},

               const Var::String& localquantumnumbers={},

               const Var::String& normalization_option={},

               const Var::String& mirroring_option={},

               const Var::String& population_option={},

               const Var::String& lineshapetype_option={},

               const Var::String& cutoff_option={},

               const Var::Numeric& cutoff_value={},

               const Var::Numeric& linemixinglimit_value={}) {

  if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to ReadJPL");

  } if (not fmin.isnull() and fmin.islast()) {

    throw std::runtime_error("fmin needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadJPL");

  } if (not fmax.isnull() and fmax.islast()) {

    throw std::runtime_error("fmax needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadJPL");

  } if (not globalquantumnumbers.isnull() and globalquantumnumbers.islast()) {

    throw std::runtime_error("globalquantumnumbers needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadJPL");

  } if (not localquantumnumbers.isnull() and localquantumnumbers.islast()) {

    throw std::runtime_error("localquantumnumbers needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadJPL");

  } if (not normalization_option.isnull() and normalization_option.islast()) {

    throw std::runtime_error("normalization_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadJPL");

  } if (not mirroring_option.isnull() and mirroring_option.islast()) {

    throw std::runtime_error("mirroring_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadJPL");

  } if (not population_option.isnull() and population_option.islast()) {

    throw std::runtime_error("population_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadJPL");

  } if (not lineshapetype_option.isnull() and lineshapetype_option.islast()) {

    throw std::runtime_error("lineshapetype_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadJPL");

  } if (not cutoff_option.isnull() and cutoff_option.islast()) {

    throw std::runtime_error("cutoff_option needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadJPL");

  } if (not cutoff_value.isnull() and cutoff_value.islast()) {

    throw std::runtime_error("cutoff_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadJPL");

  } if (not linemixinglimit_value.isnull() and linemixinglimit_value.islast()) {

    throw std::runtime_error("linemixinglimit_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ReadJPL");

  }


  static const auto fmin_default = Var::NumericCreate(ws, 0,

    "ReadJPL_fmin_autodefault",

    "auto generated variable with default from method definition");

  static const auto fmax_default = Var::NumericCreate(ws, 1e99,

    "ReadJPL_fmax_autodefault",

    "auto generated variable with default from method definition");

  static const auto globalquantumnumbers_default = Var::StringCreate(ws, "",

    "ReadJPL_globalquantumnumbers_autodefault",

    "auto generated variable with default from method definition");

  static const auto localquantumnumbers_default = Var::StringCreate(ws, "",

    "ReadJPL_localquantumnumbers_autodefault",

    "auto generated variable with default from method definition");

  static const auto normalization_option_default = Var::StringCreate(ws, "None",

    "ReadJPL_normalization_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto mirroring_option_default = Var::StringCreate(ws, "None",

    "ReadJPL_mirroring_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto population_option_default = Var::StringCreate(ws, "LTE",

    "ReadJPL_population_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto lineshapetype_option_default = Var::StringCreate(ws, "VP",

    "ReadJPL_lineshapetype_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto cutoff_option_default = Var::StringCreate(ws, "None",

    "ReadJPL_cutoff_option_autodefault",

    "auto generated variable with default from method definition");

  static const auto cutoff_value_default = Var::NumericCreate(ws, 750e9,

    "ReadJPL_cutoff_value_autodefault",

    "auto generated variable with default from method definition");

  static const auto linemixinglimit_value_default = Var::NumericCreate(ws, -1,

    "ReadJPL_linemixinglimit_value_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1223,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), fmin.isnull() ? Index(fmin_default.pos()) : Group::Index(fmin.pos()), fmax.isnull() ? Index(fmax_default.pos()) : Group::Index(fmax.pos()), globalquantumnumbers.isnull() ? Index(globalquantumnumbers_default.pos()) : Group::Index(globalquantumnumbers.pos()), localquantumnumbers.isnull() ? Index(localquantumnumbers_default.pos()) : Group::Index(localquantumnumbers.pos()), normalization_option.isnull() ? Index(normalization_option_default.pos()) : Group::Index(normalization_option.pos()), mirroring_option.isnull() ? Index(mirroring_option_default.pos()) : Group::Index(mirroring_option.pos()), population_option.isnull() ? Index(population_option_default.pos()) : Group::Index(population_option.pos()), lineshapetype_option.isnull() ? Index(lineshapetype_option_default.pos()) : Group::Index(lineshapetype_option.pos()), cutoff_option.isnull() ? Index(cutoff_option_default.pos()) : Group::Index(cutoff_option.pos()), cutoff_value.isnull() ? Index(cutoff_value_default.pos()) : Group::Index(cutoff_value.pos()), linemixinglimit_value.isnull() ? Index(linemixinglimit_value_default.pos()) : Group::Index(linemixinglimit_value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesTruncateGlobalQuantumNumbers(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1224,

    Group::ArrayOfIndex({10, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesWriteSplitXML(

    [[maybe_unused]] Workspace& ws,

               const Var::String basename) {

  if (basename.islast()) {

    throw std::runtime_error("basename needs to be a defined WorkspaceString since it is agenda input to abs_linesWriteSplitXML");

  }


  return MRecord(1225,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 10, Group::Index(basename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_linesWriteSpeciesSplitXML(

    [[maybe_unused]] Workspace& ws,

               const Var::String basename) {

  if (basename.islast()) {

    throw std::runtime_error("basename needs to be a defined WorkspaceString since it is agenda input to abs_linesWriteSpeciesSplitXML");

  }


  return MRecord(1226,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 10, Group::Index(basename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesWriteSplitXML(

    [[maybe_unused]] Workspace& ws,

               const Var::String basename) {

  if (basename.islast()) {

    throw std::runtime_error("basename needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesWriteSplitXML");

  }


  return MRecord(1227,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 11, Group::Index(basename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord abs_lines_per_speciesWriteSpeciesSplitXML(

    [[maybe_unused]] Workspace& ws,

               const Var::String basename) {

  if (basename.islast()) {

    throw std::runtime_error("basename needs to be a defined WorkspaceString since it is agenda input to abs_lines_per_speciesWriteSpeciesSplitXML");

  }


  return MRecord(1228,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 11, Group::Index(basename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadNetCDF(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of ReadNetCDF");

  } if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to ReadNetCDF");

  }


  return MRecord(1229,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadNetCDF(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of ReadNetCDF");

  } if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to ReadNetCDF");

  }


  return MRecord(1230,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadNetCDF(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 out,

               const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of ReadNetCDF");

  } if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to ReadNetCDF");

  }


  return MRecord(1231,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadNetCDF(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 out,

               const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of ReadNetCDF");

  } if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to ReadNetCDF");

  }


  return MRecord(1232,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadNetCDF(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor5 out,

               const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor5 since it is output of ReadNetCDF");

  } if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to ReadNetCDF");

  }


  return MRecord(1233,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadNetCDF(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfVector out,

               const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of ReadNetCDF");

  } if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to ReadNetCDF");

  }


  return MRecord(1234,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadNetCDF(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfMatrix out,

               const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfMatrix since it is output of ReadNetCDF");

  } if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to ReadNetCDF");

  }


  return MRecord(1235,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadNetCDF(

    [[maybe_unused]] Workspace& ws,

                     Var::GasAbsLookup out,

               const Var::String filename) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGasAbsLookup since it is output of ReadNetCDF");

  } if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to ReadNetCDF");

  }


  return MRecord(1236,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::AbsorptionLines out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceAbsorptionLines since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1237,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Agenda out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceAgenda since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1238,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfAbsorptionLines out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAbsorptionLines since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1239,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfAbsorptionLines out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1240,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfAgenda out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAgenda since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1241,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField1 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1242,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField2 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1243,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField3 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1244,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfIndex out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfIndex since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1245,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfMatrix out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1246,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfPpath out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPpath since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1247,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfPropagationMatrix out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1248,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfRadiationVector out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1249,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfScatteringMetaData out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1250,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfSingleScatteringData out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1251,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfSpeciesTag out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1252,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfStokesVector out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1253,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfString out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfString since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1254,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTensor3 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1255,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTensor6 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1256,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTime out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTime since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1257,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTransmissionMatrix out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1258,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfVector out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfVector since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1259,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfCIARecord out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfCIARecord since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1260,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField1 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField1 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1261,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField2 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField2 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1262,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField3 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1263,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField4 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField4 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1264,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfIndex out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1265,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfMatrix out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfMatrix since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1266,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfPropagationMatrix out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPropagationMatrix since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1267,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfQuantumIdentifier out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1268,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfRadiationVector out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRadiationVector since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1269,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfRetrievalQuantity out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1270,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfScatteringMetaData out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfScatteringMetaData since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1271,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSingleScatteringData out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1272,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSparse out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSparse since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1273,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfStokesVector out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfStokesVector since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1274,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfString out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfString since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1275,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTelsemAtlas out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTelsemAtlas since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1276,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor3 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor3 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1277,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor4 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor4 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1278,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor5 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor5 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1279,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor6 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor6 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1280,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor7 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor7 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1281,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTime out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTime since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1282,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTransmissionMatrix out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1283,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfVector out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1284,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfXsecRecord out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfXsecRecord since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1285,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::CIARecord out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceCIARecord since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1286,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::CovarianceMatrix out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceCovarianceMatrix since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1287,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::EnergyLevelMap out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceEnergyLevelMap since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1288,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::GasAbsLookup out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGasAbsLookup since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1289,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::GridPos out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGridPos since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1290,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField1 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField1 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1291,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField2 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField2 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1292,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField3 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField3 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1293,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField4 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField4 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1294,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField5 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField5 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1295,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField6 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField6 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1296,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::HitranRelaxationMatrixData out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceHitranRelaxationMatrixData since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1297,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Index out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1298,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::MCAntenna out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMCAntenna since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1299,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1300,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1301,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Ppath out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspacePpath since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1302,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::PropagationMatrix out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspacePropagationMatrix since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1303,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::QuantumIdentifier out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceQuantumIdentifier since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1304,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::RadiationVector out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRadiationVector since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1305,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Rational out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRational since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1306,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::ScatteringMetaData out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceScatteringMetaData since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1307,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::SingleScatteringData out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSingleScatteringData since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1308,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Sparse out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1309,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::SpeciesAuxData out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSpeciesAuxData since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1310,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::StokesVector out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceStokesVector since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1311,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::String out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceString since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1312,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::TelsemAtlas out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTelsemAtlas since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1313,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1314,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1315,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor5 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor5 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1316,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor6 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor6 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1317,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor7 out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor7 since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1318,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Timer out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTimer since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1319,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Time out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTime since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1320,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::TessemNN out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTessemNN since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1321,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::TransmissionMatrix out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTransmissionMatrix since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1322,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1323,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXML(

    [[maybe_unused]] Workspace& ws,

                     Var::Verbosity out,

               const Var::String& filename={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVerbosity since it is output of ReadXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXML_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1324,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::AbsorptionLines out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceAbsorptionLines since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1325,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Agenda out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceAgenda since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1326,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfAbsorptionLines out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAbsorptionLines since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1327,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfAbsorptionLines out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1328,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfAgenda out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfAgenda since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1329,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField1 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1330,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField2 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1331,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField3 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1332,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfIndex out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfIndex since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1333,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfMatrix out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1334,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfPpath out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPpath since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1335,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfPropagationMatrix out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1336,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfRadiationVector out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1337,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfScatteringMetaData out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1338,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfSingleScatteringData out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1339,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfSpeciesTag out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1340,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfStokesVector out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1341,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfString out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfString since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1342,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTensor3 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1343,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTensor6 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1344,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTime out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTime since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1345,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTransmissionMatrix out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1346,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfVector out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfArrayOfVector since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1347,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfCIARecord out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfCIARecord since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1348,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField1 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField1 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1349,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField2 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField2 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1350,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField3 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1351,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField4 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfGriddedField4 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1352,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfIndex out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfIndex since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1353,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfMatrix out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfMatrix since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1354,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfPropagationMatrix out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfPropagationMatrix since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1355,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfQuantumIdentifier out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1356,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfRadiationVector out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRadiationVector since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1357,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfRetrievalQuantity out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1358,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfScatteringMetaData out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfScatteringMetaData since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1359,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSingleScatteringData out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1360,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSparse out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfSparse since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1361,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfStokesVector out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfStokesVector since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1362,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfString out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfString since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1363,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTelsemAtlas out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTelsemAtlas since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1364,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor3 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor3 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1365,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor4 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor4 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1366,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor5 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor5 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1367,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor6 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor6 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1368,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor7 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTensor7 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1369,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTime out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTime since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1370,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTransmissionMatrix out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1371,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfVector out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1372,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfXsecRecord out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfXsecRecord since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1373,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::CIARecord out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceCIARecord since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1374,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::CovarianceMatrix out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceCovarianceMatrix since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1375,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::EnergyLevelMap out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceEnergyLevelMap since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1376,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::GasAbsLookup out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGasAbsLookup since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1377,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::GridPos out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGridPos since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1378,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField1 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField1 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1379,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField2 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField2 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1380,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField3 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField3 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1381,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField4 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField4 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1382,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField5 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField5 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1383,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField6 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceGriddedField6 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1384,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::HitranRelaxationMatrixData out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceHitranRelaxationMatrixData since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1385,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Index out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceIndex since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1386,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::MCAntenna out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMCAntenna since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1387,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceMatrix since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1388,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceNumeric since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1389,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Ppath out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspacePpath since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1390,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::PropagationMatrix out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspacePropagationMatrix since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1391,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::QuantumIdentifier out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceQuantumIdentifier since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1392,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::RadiationVector out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRadiationVector since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1393,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Rational out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceRational since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1394,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::ScatteringMetaData out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceScatteringMetaData since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1395,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::SingleScatteringData out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSingleScatteringData since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1396,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Sparse out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1397,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::SpeciesAuxData out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSpeciesAuxData since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1398,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::StokesVector out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceStokesVector since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1399,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::String out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceString since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1400,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::TelsemAtlas out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTelsemAtlas since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1401,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1402,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1403,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor5 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor5 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1404,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor6 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor6 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1405,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor7 out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor7 since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1406,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Timer out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTimer since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1407,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Time out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTime since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1408,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::TessemNN out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTessemNN since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1409,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::TransmissionMatrix out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTransmissionMatrix since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1410,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1411,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ReadXMLIndexed(

    [[maybe_unused]] Workspace& ws,

                     Var::Verbosity out,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVerbosity since it is output of ReadXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to ReadXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ReadXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "ReadXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "ReadXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1412,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({97, filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric o,

               const Var::Vector i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceNumeric since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceVector since it is agenda input to Reduce");

  }


  return MRecord(1413,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric o,

               const Var::Matrix i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceNumeric since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceMatrix since it is agenda input to Reduce");

  }


  return MRecord(1414,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric o,

               const Var::Tensor3 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceNumeric since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor3 since it is agenda input to Reduce");

  }


  return MRecord(1415,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric o,

               const Var::Tensor4 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceNumeric since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor4 since it is agenda input to Reduce");

  }


  return MRecord(1416,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric o,

               const Var::Tensor5 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceNumeric since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor5 since it is agenda input to Reduce");

  }


  return MRecord(1417,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric o,

               const Var::Tensor6 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceNumeric since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor6 since it is agenda input to Reduce");

  }


  return MRecord(1418,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric o,

               const Var::Tensor7 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceNumeric since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor7 since it is agenda input to Reduce");

  }


  return MRecord(1419,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector o,

               const Var::Matrix i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceVector since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceMatrix since it is agenda input to Reduce");

  }


  return MRecord(1420,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector o,

               const Var::Tensor3 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceVector since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor3 since it is agenda input to Reduce");

  }


  return MRecord(1421,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector o,

               const Var::Tensor4 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceVector since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor4 since it is agenda input to Reduce");

  }


  return MRecord(1422,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector o,

               const Var::Tensor5 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceVector since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor5 since it is agenda input to Reduce");

  }


  return MRecord(1423,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector o,

               const Var::Tensor6 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceVector since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor6 since it is agenda input to Reduce");

  }


  return MRecord(1424,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector o,

               const Var::Tensor7 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceVector since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor7 since it is agenda input to Reduce");

  }


  return MRecord(1425,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix o,

               const Var::Tensor3 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceMatrix since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor3 since it is agenda input to Reduce");

  }


  return MRecord(1426,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix o,

               const Var::Tensor4 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceMatrix since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor4 since it is agenda input to Reduce");

  }


  return MRecord(1427,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix o,

               const Var::Tensor5 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceMatrix since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor5 since it is agenda input to Reduce");

  }


  return MRecord(1428,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix o,

               const Var::Tensor6 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceMatrix since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor6 since it is agenda input to Reduce");

  }


  return MRecord(1429,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix o,

               const Var::Tensor7 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceMatrix since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor7 since it is agenda input to Reduce");

  }


  return MRecord(1430,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 o,

               const Var::Tensor4 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor3 since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor4 since it is agenda input to Reduce");

  }


  return MRecord(1431,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 o,

               const Var::Tensor5 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor3 since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor5 since it is agenda input to Reduce");

  }


  return MRecord(1432,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 o,

               const Var::Tensor6 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor3 since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor6 since it is agenda input to Reduce");

  }


  return MRecord(1433,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 o,

               const Var::Tensor7 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor3 since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor7 since it is agenda input to Reduce");

  }


  return MRecord(1434,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 o,

               const Var::Tensor5 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor4 since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor5 since it is agenda input to Reduce");

  }


  return MRecord(1435,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 o,

               const Var::Tensor6 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor4 since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor6 since it is agenda input to Reduce");

  }


  return MRecord(1436,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 o,

               const Var::Tensor7 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor4 since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor7 since it is agenda input to Reduce");

  }


  return MRecord(1437,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor5 o,

               const Var::Tensor6 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor5 since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor6 since it is agenda input to Reduce");

  }


  return MRecord(1438,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor5 o,

               const Var::Tensor7 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor5 since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor7 since it is agenda input to Reduce");

  }


  return MRecord(1439,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Reduce(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor6 o,

               const Var::Tensor7 i) {

  if (o.islast()) {

    throw std::runtime_error("o needs to be a defined WorkspaceTensor6 since it is output of Reduce");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceTensor7 since it is agenda input to Reduce");

  }


  return MRecord(1440,

    Group::ArrayOfIndex({Group::Index(o.pos()), }),

    Group::ArrayOfIndex({Group::Index(i.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refellipsoidEarth(

    [[maybe_unused]] Workspace& ws,

               const Var::String& model={}) {

  if (not model.isnull() and model.islast()) {

    throw std::runtime_error("model needs to be a defined WorkspaceString (or left default) since it is agenda input to refellipsoidEarth");

  }


  static const auto model_default = Var::StringCreate(ws, "Sphere",

    "refellipsoidEarth_model_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1441,

    Group::ArrayOfIndex({250, }),

    Group::ArrayOfIndex({model.isnull() ? Index(model_default.pos()) : Group::Index(model.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refellipsoidGanymede(

    [[maybe_unused]] Workspace& ws,

               const Var::String& model={}) {

  if (not model.isnull() and model.islast()) {

    throw std::runtime_error("model needs to be a defined WorkspaceString (or left default) since it is agenda input to refellipsoidGanymede");

  }


  static const auto model_default = Var::StringCreate(ws, "Sphere",

    "refellipsoidGanymede_model_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1442,

    Group::ArrayOfIndex({250, }),

    Group::ArrayOfIndex({model.isnull() ? Index(model_default.pos()) : Group::Index(model.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refellipsoidForAzimuth(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric latitude,

               const Var::Numeric azimuth) {

  if (latitude.islast()) {

    throw std::runtime_error("latitude needs to be a defined WorkspaceNumeric since it is agenda input to refellipsoidForAzimuth");

  } if (azimuth.islast()) {

    throw std::runtime_error("azimuth needs to be a defined WorkspaceNumeric since it is agenda input to refellipsoidForAzimuth");

  }


  return MRecord(1443,

    Group::ArrayOfIndex({250, }),

    Group::ArrayOfIndex({Group::Index(latitude.pos()), Group::Index(azimuth.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refellipsoidEuropa(

    [[maybe_unused]] Workspace& ws,

               const Var::String& model={}) {

  if (not model.isnull() and model.islast()) {

    throw std::runtime_error("model needs to be a defined WorkspaceString (or left default) since it is agenda input to refellipsoidEuropa");

  }


  static const auto model_default = Var::StringCreate(ws, "Sphere",

    "refellipsoidEuropa_model_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1444,

    Group::ArrayOfIndex({250, }),

    Group::ArrayOfIndex({model.isnull() ? Index(model_default.pos()) : Group::Index(model.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refellipsoidIo(

    [[maybe_unused]] Workspace& ws,

               const Var::String& model={}) {

  if (not model.isnull() and model.islast()) {

    throw std::runtime_error("model needs to be a defined WorkspaceString (or left default) since it is agenda input to refellipsoidIo");

  }


  static const auto model_default = Var::StringCreate(ws, "Sphere",

    "refellipsoidIo_model_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1445,

    Group::ArrayOfIndex({250, }),

    Group::ArrayOfIndex({model.isnull() ? Index(model_default.pos()) : Group::Index(model.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refellipsoidJupiter(

    [[maybe_unused]] Workspace& ws,

               const Var::String& model={}) {

  if (not model.isnull() and model.islast()) {

    throw std::runtime_error("model needs to be a defined WorkspaceString (or left default) since it is agenda input to refellipsoidJupiter");

  }


  static const auto model_default = Var::StringCreate(ws, "Sphere",

    "refellipsoidJupiter_model_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1446,

    Group::ArrayOfIndex({250, }),

    Group::ArrayOfIndex({model.isnull() ? Index(model_default.pos()) : Group::Index(model.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refellipsoidMars(

    [[maybe_unused]] Workspace& ws,

               const Var::String& model={}) {

  if (not model.isnull() and model.islast()) {

    throw std::runtime_error("model needs to be a defined WorkspaceString (or left default) since it is agenda input to refellipsoidMars");

  }


  static const auto model_default = Var::StringCreate(ws, "Sphere",

    "refellipsoidMars_model_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1447,

    Group::ArrayOfIndex({250, }),

    Group::ArrayOfIndex({model.isnull() ? Index(model_default.pos()) : Group::Index(model.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refellipsoidMoon(

    [[maybe_unused]] Workspace& ws,

               const Var::String& model={}) {

  if (not model.isnull() and model.islast()) {

    throw std::runtime_error("model needs to be a defined WorkspaceString (or left default) since it is agenda input to refellipsoidMoon");

  }


  static const auto model_default = Var::StringCreate(ws, "Sphere",

    "refellipsoidMoon_model_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1448,

    Group::ArrayOfIndex({250, }),

    Group::ArrayOfIndex({model.isnull() ? Index(model_default.pos()) : Group::Index(model.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refellipsoidOrbitPlane(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric orbitinc) {

  if (orbitinc.islast()) {

    throw std::runtime_error("orbitinc needs to be a defined WorkspaceNumeric since it is agenda input to refellipsoidOrbitPlane");

  }


  return MRecord(1449,

    Group::ArrayOfIndex({250, }),

    Group::ArrayOfIndex({Group::Index(orbitinc.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refellipsoidSet(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric re,

               const Var::Numeric& e={}) {

  if (re.islast()) {

    throw std::runtime_error("re needs to be a defined WorkspaceNumeric since it is agenda input to refellipsoidSet");

  } if (not e.isnull() and e.islast()) {

    throw std::runtime_error("e needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to refellipsoidSet");

  }


  static const auto e_default = Var::NumericCreate(ws, 0,

    "refellipsoidSet_e_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1450,

    Group::ArrayOfIndex({250, }),

    Group::ArrayOfIndex({Group::Index(re.pos()), e.isnull() ? Index(e_default.pos()) : Group::Index(e.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refellipsoidVenus(

    [[maybe_unused]] Workspace& ws,

               const Var::String& model={}) {

  if (not model.isnull() and model.islast()) {

    throw std::runtime_error("model needs to be a defined WorkspaceString (or left default) since it is agenda input to refellipsoidVenus");

  }


  static const auto model_default = Var::StringCreate(ws, "Sphere",

    "refellipsoidVenus_model_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1451,

    Group::ArrayOfIndex({250, }),

    Group::ArrayOfIndex({model.isnull() ? Index(model_default.pos()) : Group::Index(model.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refr_index_airFreeElectrons(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& demand_vmr_value={}) {

  if (not demand_vmr_value.isnull() and demand_vmr_value.islast()) {

    throw std::runtime_error("demand_vmr_value needs to be a defined WorkspaceIndex (or left default) since it is agenda input to refr_index_airFreeElectrons");

  }


  static const auto demand_vmr_value_default = Var::IndexCreate(ws, 1,

    "refr_index_airFreeElectrons_demand_vmr_value_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1452,

    Group::ArrayOfIndex({247, 249, }),

    Group::ArrayOfIndex({104, 21, 266, demand_vmr_value.isnull() ? Index(demand_vmr_value_default.pos()) : Group::Index(demand_vmr_value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refr_index_airInfraredEarth(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1453,

    Group::ArrayOfIndex({247, 249, }),

    Group::ArrayOfIndex({263, 264, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refr_index_airMicrowavesEarth(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& k1={},

               const Var::Numeric& k2={},

               const Var::Numeric& k3={}) {

  if (not k1.isnull() and k1.islast()) {

    throw std::runtime_error("k1 needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to refr_index_airMicrowavesEarth");

  } if (not k2.isnull() and k2.islast()) {

    throw std::runtime_error("k2 needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to refr_index_airMicrowavesEarth");

  } if (not k3.isnull() and k3.islast()) {

    throw std::runtime_error("k3 needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to refr_index_airMicrowavesEarth");

  }


  static const auto k1_default = Var::NumericCreate(ws, 77.6e-8,

    "refr_index_airMicrowavesEarth_k1_autodefault",

    "auto generated variable with default from method definition");

  static const auto k2_default = Var::NumericCreate(ws, 70.4e-8,

    "refr_index_airMicrowavesEarth_k2_autodefault",

    "auto generated variable with default from method definition");

  static const auto k3_default = Var::NumericCreate(ws, 3.739e-3,

    "refr_index_airMicrowavesEarth_k3_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1454,

    Group::ArrayOfIndex({247, 249, }),

    Group::ArrayOfIndex({263, 264, 266, 21, k1.isnull() ? Index(k1_default.pos()) : Group::Index(k1.pos()), k2.isnull() ? Index(k2_default.pos()) : Group::Index(k2.pos()), k3.isnull() ? Index(k3_default.pos()) : Group::Index(k3.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord refr_index_airMicrowavesGeneral(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1455,

    Group::ArrayOfIndex({247, 249, }),

    Group::ArrayOfIndex({263, 264, 266, 21, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalDefClose(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1456,

    Group::ArrayOfIndex({136, 135, 253, }),

    Group::ArrayOfIndex({60, 137, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalAddAbsSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::Vector g3,

               const Var::String species,

               const Var::String& unit={},

               const Var::Index& for_species_tag={}) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddAbsSpecies");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddAbsSpecies");

  } if (g3.islast()) {

    throw std::runtime_error("g3 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddAbsSpecies");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to retrievalAddAbsSpecies");

  } if (not unit.isnull() and unit.islast()) {

    throw std::runtime_error("unit needs to be a defined WorkspaceString (or left default) since it is agenda input to retrievalAddAbsSpecies");

  } if (not for_species_tag.isnull() and for_species_tag.islast()) {

    throw std::runtime_error("for_species_tag needs to be a defined WorkspaceIndex (or left default) since it is agenda input to retrievalAddAbsSpecies");

  }


  static const auto unit_default = Var::StringCreate(ws, "rel",

    "retrievalAddAbsSpecies_unit_autodefault",

    "auto generated variable with default from method definition");

  static const auto for_species_tag_default = Var::IndexCreate(ws, 1,

    "retrievalAddAbsSpecies_for_species_tag_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1457,

    Group::ArrayOfIndex({60, 137, 135, }),

    Group::ArrayOfIndex({35, 56, 57, 242, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(g3.pos()), Group::Index(species.pos()), unit.isnull() ? Index(unit_default.pos()) : Group::Index(unit.pos()), for_species_tag.isnull() ? Index(for_species_tag_default.pos()) : Group::Index(for_species_tag.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalAddFreqShift(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& df={}) {

  if (not df.isnull() and df.islast()) {

    throw std::runtime_error("df needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to retrievalAddFreqShift");

  }


  static const auto df_default = Var::NumericCreate(ws, 100e3,

    "retrievalAddFreqShift_df_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1458,

    Group::ArrayOfIndex({60, 137, 135, }),

    Group::ArrayOfIndex({56, 57, 104, df.isnull() ? Index(df_default.pos()) : Group::Index(df.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalAddFreqStretch(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& df={}) {

  if (not df.isnull() and df.islast()) {

    throw std::runtime_error("df needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to retrievalAddFreqStretch");

  }


  static const auto df_default = Var::NumericCreate(ws, 100e3,

    "retrievalAddFreqStretch_df_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1459,

    Group::ArrayOfIndex({60, 137, 135, }),

    Group::ArrayOfIndex({104, 56, 57, df.isnull() ? Index(df_default.pos()) : Group::Index(df.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalDefInit(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& initialize_jacobian={}) {

  if (not initialize_jacobian.isnull() and initialize_jacobian.islast()) {

    throw std::runtime_error("initialize_jacobian needs to be a defined WorkspaceIndex (or left default) since it is agenda input to retrievalDefInit");

  }


  static const auto initialize_jacobian_default = Var::IndexCreate(ws, 1,

    "retrievalDefInit_initialize_jacobian_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1460,

    Group::ArrayOfIndex({58, 60, 56, 57, 137, 135, }),

    Group::ArrayOfIndex({initialize_jacobian.isnull() ? Index(initialize_jacobian_default.pos()) : Group::Index(initialize_jacobian.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalAddCatalogParameter(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier catalog_identity,

               const Var::String catalog_parameter,

               const Var::Numeric var) {

  if (catalog_identity.islast()) {

    throw std::runtime_error("catalog_identity needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to retrievalAddCatalogParameter");

  } if (catalog_parameter.islast()) {

    throw std::runtime_error("catalog_parameter needs to be a defined WorkspaceString since it is agenda input to retrievalAddCatalogParameter");

  } if (var.islast()) {

    throw std::runtime_error("var needs to be a defined WorkspaceNumeric since it is agenda input to retrievalAddCatalogParameter");

  }


  return MRecord(1461,

    Group::ArrayOfIndex({60, 137, 135, }),

    Group::ArrayOfIndex({Group::Index(catalog_identity.pos()), Group::Index(catalog_parameter.pos()), Group::Index(var.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalAddCatalogParameters(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier catalog_identities,

               const Var::ArrayOfString catalog_parameters) {

  if (catalog_identities.islast()) {

    throw std::runtime_error("catalog_identities needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to retrievalAddCatalogParameters");

  } if (catalog_parameters.islast()) {

    throw std::runtime_error("catalog_parameters needs to be a defined WorkspaceArrayOfString since it is agenda input to retrievalAddCatalogParameters");

  }


  return MRecord(1462,

    Group::ArrayOfIndex({60, 137, 135, }),

    Group::ArrayOfIndex({56, 57, Group::Index(catalog_identities.pos()), Group::Index(catalog_parameters.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalAddMagField(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::Vector g3,

               const Var::String& component={},

               const Var::Numeric& dB={}) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddMagField");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddMagField");

  } if (g3.islast()) {

    throw std::runtime_error("g3 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddMagField");

  } if (not component.isnull() and component.islast()) {

    throw std::runtime_error("component needs to be a defined WorkspaceString (or left default) since it is agenda input to retrievalAddMagField");

  } if (not dB.isnull() and dB.islast()) {

    throw std::runtime_error("dB needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to retrievalAddMagField");

  }


  static const auto component_default = Var::StringCreate(ws, "v",

    "retrievalAddMagField_component_autodefault",

    "auto generated variable with default from method definition");

  static const auto dB_default = Var::NumericCreate(ws, 1.0e-7,

    "retrievalAddMagField_dB_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1463,

    Group::ArrayOfIndex({60, 137, 135, }),

    Group::ArrayOfIndex({35, 56, 57, 242, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(g3.pos()), component.isnull() ? Index(component_default.pos()) : Group::Index(component.pos()), dB.isnull() ? Index(dB_default.pos()) : Group::Index(dB.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalAddPointingZa(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& poly_order={},

               const Var::String& calcmode={},

               const Var::Numeric& dza={}) {

  if (not poly_order.isnull() and poly_order.islast()) {

    throw std::runtime_error("poly_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to retrievalAddPointingZa");

  } if (not calcmode.isnull() and calcmode.islast()) {

    throw std::runtime_error("calcmode needs to be a defined WorkspaceString (or left default) since it is agenda input to retrievalAddPointingZa");

  } if (not dza.isnull() and dza.islast()) {

    throw std::runtime_error("dza needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to retrievalAddPointingZa");

  }


  static const auto poly_order_default = Var::IndexCreate(ws, 0,

    "retrievalAddPointingZa_poly_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto calcmode_default = Var::StringCreate(ws, "recalc",

    "retrievalAddPointingZa_calcmode_autodefault",

    "auto generated variable with default from method definition");

  static const auto dza_default = Var::NumericCreate(ws, 0.01,

    "retrievalAddPointingZa_dza_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1464,

    Group::ArrayOfIndex({60, 137, 135, }),

    Group::ArrayOfIndex({56, 57, 286, 296, poly_order.isnull() ? Index(poly_order_default.pos()) : Group::Index(poly_order.pos()), calcmode.isnull() ? Index(calcmode_default.pos()) : Group::Index(calcmode.pos()), dza.isnull() ? Index(dza_default.pos()) : Group::Index(dza.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalAddPolyfit(

    [[maybe_unused]] Workspace& ws,

               const Var::Index poly_order,

               const Var::Index& no_pol_variation={},

               const Var::Index& no_los_variation={},

               const Var::Index& no_mblock_variation={}) {

  if (poly_order.islast()) {

    throw std::runtime_error("poly_order needs to be a defined WorkspaceIndex since it is agenda input to retrievalAddPolyfit");

  } if (not no_pol_variation.isnull() and no_pol_variation.islast()) {

    throw std::runtime_error("no_pol_variation needs to be a defined WorkspaceIndex (or left default) since it is agenda input to retrievalAddPolyfit");

  } if (not no_los_variation.isnull() and no_los_variation.islast()) {

    throw std::runtime_error("no_los_variation needs to be a defined WorkspaceIndex (or left default) since it is agenda input to retrievalAddPolyfit");

  } if (not no_mblock_variation.isnull() and no_mblock_variation.islast()) {

    throw std::runtime_error("no_mblock_variation needs to be a defined WorkspaceIndex (or left default) since it is agenda input to retrievalAddPolyfit");

  }


  static const auto no_pol_variation_default = Var::IndexCreate(ws, 0,

    "retrievalAddPolyfit_no_pol_variation_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_los_variation_default = Var::IndexCreate(ws, 0,

    "retrievalAddPolyfit_no_los_variation_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_mblock_variation_default = Var::IndexCreate(ws, 0,

    "retrievalAddPolyfit_no_mblock_variation_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1465,

    Group::ArrayOfIndex({60, 137, 135, }),

    Group::ArrayOfIndex({56, 57, 295, 291, 286, Group::Index(poly_order.pos()), no_pol_variation.isnull() ? Index(no_pol_variation_default.pos()) : Group::Index(no_pol_variation.pos()), no_los_variation.isnull() ? Index(no_los_variation_default.pos()) : Group::Index(no_los_variation.pos()), no_mblock_variation.isnull() ? Index(no_mblock_variation_default.pos()) : Group::Index(no_mblock_variation.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalAddScatSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::Vector g3,

               const Var::String species,

               const Var::String quantity) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddScatSpecies");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddScatSpecies");

  } if (g3.islast()) {

    throw std::runtime_error("g3 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddScatSpecies");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to retrievalAddScatSpecies");

  } if (quantity.islast()) {

    throw std::runtime_error("quantity needs to be a defined WorkspaceString since it is agenda input to retrievalAddScatSpecies");

  }


  return MRecord(1466,

    Group::ArrayOfIndex({60, 137, 135, }),

    Group::ArrayOfIndex({35, 56, 57, 242, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(g3.pos()), Group::Index(species.pos()), Group::Index(quantity.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalAddSinefit(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector period_lengths,

               const Var::Index& no_pol_variation={},

               const Var::Index& no_los_variation={},

               const Var::Index& no_mblock_variation={}) {

  if (period_lengths.islast()) {

    throw std::runtime_error("period_lengths needs to be a defined WorkspaceVector since it is agenda input to retrievalAddSinefit");

  } if (not no_pol_variation.isnull() and no_pol_variation.islast()) {

    throw std::runtime_error("no_pol_variation needs to be a defined WorkspaceIndex (or left default) since it is agenda input to retrievalAddSinefit");

  } if (not no_los_variation.isnull() and no_los_variation.islast()) {

    throw std::runtime_error("no_los_variation needs to be a defined WorkspaceIndex (or left default) since it is agenda input to retrievalAddSinefit");

  } if (not no_mblock_variation.isnull() and no_mblock_variation.islast()) {

    throw std::runtime_error("no_mblock_variation needs to be a defined WorkspaceIndex (or left default) since it is agenda input to retrievalAddSinefit");

  }


  static const auto no_pol_variation_default = Var::IndexCreate(ws, 0,

    "retrievalAddSinefit_no_pol_variation_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_los_variation_default = Var::IndexCreate(ws, 0,

    "retrievalAddSinefit_no_los_variation_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_mblock_variation_default = Var::IndexCreate(ws, 0,

    "retrievalAddSinefit_no_mblock_variation_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1467,

    Group::ArrayOfIndex({60, 137, 135, }),

    Group::ArrayOfIndex({56, 57, 295, 291, 286, Group::Index(period_lengths.pos()), no_pol_variation.isnull() ? Index(no_pol_variation_default.pos()) : Group::Index(no_pol_variation.pos()), no_los_variation.isnull() ? Index(no_los_variation_default.pos()) : Group::Index(no_los_variation.pos()), no_mblock_variation.isnull() ? Index(no_mblock_variation_default.pos()) : Group::Index(no_mblock_variation.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalAddSpecialSpecies(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::Vector g3,

               const Var::String species) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddSpecialSpecies");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddSpecialSpecies");

  } if (g3.islast()) {

    throw std::runtime_error("g3 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddSpecialSpecies");

  } if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to retrievalAddSpecialSpecies");

  }


  return MRecord(1468,

    Group::ArrayOfIndex({60, 137, 135, }),

    Group::ArrayOfIndex({35, 56, 57, 242, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(g3.pos()), Group::Index(species.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalAddSurfaceQuantity(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::String quantity) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddSurfaceQuantity");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddSurfaceQuantity");

  } if (quantity.islast()) {

    throw std::runtime_error("quantity needs to be a defined WorkspaceString since it is agenda input to retrievalAddSurfaceQuantity");

  }


  return MRecord(1469,

    Group::ArrayOfIndex({60, 137, 135, }),

    Group::ArrayOfIndex({56, 57, 35, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(quantity.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalAddTemperature(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::Vector g3,

               const Var::String& hse={}) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddTemperature");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddTemperature");

  } if (g3.islast()) {

    throw std::runtime_error("g3 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddTemperature");

  } if (not hse.isnull() and hse.islast()) {

    throw std::runtime_error("hse needs to be a defined WorkspaceString (or left default) since it is agenda input to retrievalAddTemperature");

  }


  static const auto hse_default = Var::StringCreate(ws, "on",

    "retrievalAddTemperature_hse_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1470,

    Group::ArrayOfIndex({60, 137, 135, }),

    Group::ArrayOfIndex({35, 56, 57, 242, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(g3.pos()), hse.isnull() ? Index(hse_default.pos()) : Group::Index(hse.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalAddWind(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector g1,

               const Var::Vector g2,

               const Var::Vector g3,

               const Var::String& component={},

               const Var::Numeric& dfrequency={}) {

  if (g1.islast()) {

    throw std::runtime_error("g1 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddWind");

  } if (g2.islast()) {

    throw std::runtime_error("g2 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddWind");

  } if (g3.islast()) {

    throw std::runtime_error("g3 needs to be a defined WorkspaceVector since it is agenda input to retrievalAddWind");

  } if (not component.isnull() and component.islast()) {

    throw std::runtime_error("component needs to be a defined WorkspaceString (or left default) since it is agenda input to retrievalAddWind");

  } if (not dfrequency.isnull() and dfrequency.islast()) {

    throw std::runtime_error("dfrequency needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to retrievalAddWind");

  }


  static const auto component_default = Var::StringCreate(ws, "v",

    "retrievalAddWind_component_autodefault",

    "auto generated variable with default from method definition");

  static const auto dfrequency_default = Var::NumericCreate(ws, 0.1,

    "retrievalAddWind_dfrequency_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1471,

    Group::ArrayOfIndex({60, 137, 135, }),

    Group::ArrayOfIndex({35, 56, 57, 242, 139, 147, Group::Index(g1.pos()), Group::Index(g2.pos()), Group::Index(g3.pos()), component.isnull() ? Index(component_default.pos()) : Group::Index(component.pos()), dfrequency.isnull() ? Index(dfrequency_default.pos()) : Group::Index(dfrequency.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord retrievalErrorsExtract(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1472,

    Group::ArrayOfIndex({254, 255, }),

    Group::ArrayOfIndex({61, 62, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord RT4Calc(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& nstreams={},

               const Var::String& pfct_method={},

               const Var::String& quad_type={},

               const Var::Index& add_straight_angles={},

               const Var::Index& pfct_aa_grid_size={},

               const Var::Index& auto_inc_nstreams={},

               const Var::Index& robust={},

               const Var::Index& za_interp_order={},

               const Var::Index& cos_za_interp={},

               const Var::Numeric& max_delta_tau={}) {

  if (not nstreams.isnull() and nstreams.islast()) {

    throw std::runtime_error("nstreams needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RT4Calc");

  } if (not pfct_method.isnull() and pfct_method.islast()) {

    throw std::runtime_error("pfct_method needs to be a defined WorkspaceString (or left default) since it is agenda input to RT4Calc");

  } if (not quad_type.isnull() and quad_type.islast()) {

    throw std::runtime_error("quad_type needs to be a defined WorkspaceString (or left default) since it is agenda input to RT4Calc");

  } if (not add_straight_angles.isnull() and add_straight_angles.islast()) {

    throw std::runtime_error("add_straight_angles needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RT4Calc");

  } if (not pfct_aa_grid_size.isnull() and pfct_aa_grid_size.islast()) {

    throw std::runtime_error("pfct_aa_grid_size needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RT4Calc");

  } if (not auto_inc_nstreams.isnull() and auto_inc_nstreams.islast()) {

    throw std::runtime_error("auto_inc_nstreams needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RT4Calc");

  } if (not robust.isnull() and robust.islast()) {

    throw std::runtime_error("robust needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RT4Calc");

  } if (not za_interp_order.isnull() and za_interp_order.islast()) {

    throw std::runtime_error("za_interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RT4Calc");

  } if (not cos_za_interp.isnull() and cos_za_interp.islast()) {

    throw std::runtime_error("cos_za_interp needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RT4Calc");

  } if (not max_delta_tau.isnull() and max_delta_tau.islast()) {

    throw std::runtime_error("max_delta_tau needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to RT4Calc");

  }


  static const auto nstreams_default = Var::IndexCreate(ws, 16,

    "RT4Calc_nstreams_autodefault",

    "auto generated variable with default from method definition");

  static const auto pfct_method_default = Var::StringCreate(ws, "median",

    "RT4Calc_pfct_method_autodefault",

    "auto generated variable with default from method definition");

  static const auto quad_type_default = Var::StringCreate(ws, "D",

    "RT4Calc_quad_type_autodefault",

    "auto generated variable with default from method definition");

  static const auto add_straight_angles_default = Var::IndexCreate(ws, 1,

    "RT4Calc_add_straight_angles_autodefault",

    "auto generated variable with default from method definition");

  static const auto pfct_aa_grid_size_default = Var::IndexCreate(ws, 19,

    "RT4Calc_pfct_aa_grid_size_autodefault",

    "auto generated variable with default from method definition");

  static const auto auto_inc_nstreams_default = Var::IndexCreate(ws, 0,

    "RT4Calc_auto_inc_nstreams_autodefault",

    "auto generated variable with default from method definition");

  static const auto robust_default = Var::IndexCreate(ws, 0,

    "RT4Calc_robust_autodefault",

    "auto generated variable with default from method definition");

  static const auto za_interp_order_default = Var::IndexCreate(ws, 1,

    "RT4Calc_za_interp_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto cos_za_interp_default = Var::IndexCreate(ws, 0,

    "RT4Calc_cos_za_interp_autodefault",

    "auto generated variable with default from method definition");

  static const auto max_delta_tau_default = Var::NumericCreate(ws, 1e-6,

    "RT4Calc_max_delta_tau_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1473,

    Group::ArrayOfIndex({49, 378, 0, }),

    Group::ArrayOfIndex({36, 37, 268, 48, 53, 52, 238, 318, 35, 213, 338, 381, 344, 242, 267, 104, 306, 384, nstreams.isnull() ? Index(nstreams_default.pos()) : Group::Index(nstreams.pos()), pfct_method.isnull() ? Index(pfct_method_default.pos()) : Group::Index(pfct_method.pos()), quad_type.isnull() ? Index(quad_type_default.pos()) : Group::Index(quad_type.pos()), add_straight_angles.isnull() ? Index(add_straight_angles_default.pos()) : Group::Index(add_straight_angles.pos()), pfct_aa_grid_size.isnull() ? Index(pfct_aa_grid_size_default.pos()) : Group::Index(pfct_aa_grid_size.pos()), auto_inc_nstreams.isnull() ? Index(auto_inc_nstreams_default.pos()) : Group::Index(auto_inc_nstreams.pos()), robust.isnull() ? Index(robust_default.pos()) : Group::Index(robust.pos()), za_interp_order.isnull() ? Index(za_interp_order_default.pos()) : Group::Index(za_interp_order.pos()), cos_za_interp.isnull() ? Index(cos_za_interp_default.pos()) : Group::Index(cos_za_interp.pos()), max_delta_tau.isnull() ? Index(max_delta_tau_default.pos()) : Group::Index(max_delta_tau.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord RT4CalcWithRT4Surface(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& nstreams={},

               const Var::String& pfct_method={},

               const Var::String& ground_type={},

               const Var::String& quad_type={},

               const Var::Index& add_straight_angles={},

               const Var::Index& pfct_aa_grid_size={},

               const Var::Index& auto_inc_nstreams={},

               const Var::Index& robust={},

               const Var::Index& za_interp_order={},

               const Var::Index& cos_za_interp={},

               const Var::Numeric& max_delta_tau={}) {

  if (not nstreams.isnull() and nstreams.islast()) {

    throw std::runtime_error("nstreams needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RT4CalcWithRT4Surface");

  } if (not pfct_method.isnull() and pfct_method.islast()) {

    throw std::runtime_error("pfct_method needs to be a defined WorkspaceString (or left default) since it is agenda input to RT4CalcWithRT4Surface");

  } if (not ground_type.isnull() and ground_type.islast()) {

    throw std::runtime_error("ground_type needs to be a defined WorkspaceString (or left default) since it is agenda input to RT4CalcWithRT4Surface");

  } if (not quad_type.isnull() and quad_type.islast()) {

    throw std::runtime_error("quad_type needs to be a defined WorkspaceString (or left default) since it is agenda input to RT4CalcWithRT4Surface");

  } if (not add_straight_angles.isnull() and add_straight_angles.islast()) {

    throw std::runtime_error("add_straight_angles needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RT4CalcWithRT4Surface");

  } if (not pfct_aa_grid_size.isnull() and pfct_aa_grid_size.islast()) {

    throw std::runtime_error("pfct_aa_grid_size needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RT4CalcWithRT4Surface");

  } if (not auto_inc_nstreams.isnull() and auto_inc_nstreams.islast()) {

    throw std::runtime_error("auto_inc_nstreams needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RT4CalcWithRT4Surface");

  } if (not robust.isnull() and robust.islast()) {

    throw std::runtime_error("robust needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RT4CalcWithRT4Surface");

  } if (not za_interp_order.isnull() and za_interp_order.islast()) {

    throw std::runtime_error("za_interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RT4CalcWithRT4Surface");

  } if (not cos_za_interp.isnull() and cos_za_interp.islast()) {

    throw std::runtime_error("cos_za_interp needs to be a defined WorkspaceIndex (or left default) since it is agenda input to RT4CalcWithRT4Surface");

  } if (not max_delta_tau.isnull() and max_delta_tau.islast()) {

    throw std::runtime_error("max_delta_tau needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to RT4CalcWithRT4Surface");

  }


  static const auto nstreams_default = Var::IndexCreate(ws, 16,

    "RT4CalcWithRT4Surface_nstreams_autodefault",

    "auto generated variable with default from method definition");

  static const auto pfct_method_default = Var::StringCreate(ws, "median",

    "RT4CalcWithRT4Surface_pfct_method_autodefault",

    "auto generated variable with default from method definition");

  static const auto ground_type_default = Var::StringCreate(ws, "A",

    "RT4CalcWithRT4Surface_ground_type_autodefault",

    "auto generated variable with default from method definition");

  static const auto quad_type_default = Var::StringCreate(ws, "D",

    "RT4CalcWithRT4Surface_quad_type_autodefault",

    "auto generated variable with default from method definition");

  static const auto add_straight_angles_default = Var::IndexCreate(ws, 1,

    "RT4CalcWithRT4Surface_add_straight_angles_autodefault",

    "auto generated variable with default from method definition");

  static const auto pfct_aa_grid_size_default = Var::IndexCreate(ws, 19,

    "RT4CalcWithRT4Surface_pfct_aa_grid_size_autodefault",

    "auto generated variable with default from method definition");

  static const auto auto_inc_nstreams_default = Var::IndexCreate(ws, 0,

    "RT4CalcWithRT4Surface_auto_inc_nstreams_autodefault",

    "auto generated variable with default from method definition");

  static const auto robust_default = Var::IndexCreate(ws, 0,

    "RT4CalcWithRT4Surface_robust_autodefault",

    "auto generated variable with default from method definition");

  static const auto za_interp_order_default = Var::IndexCreate(ws, 1,

    "RT4CalcWithRT4Surface_za_interp_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto cos_za_interp_default = Var::IndexCreate(ws, 0,

    "RT4CalcWithRT4Surface_cos_za_interp_autodefault",

    "auto generated variable with default from method definition");

  static const auto max_delta_tau_default = Var::NumericCreate(ws, 1e-6,

    "RT4CalcWithRT4Surface_max_delta_tau_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1474,

    Group::ArrayOfIndex({49, 378, 0, }),

    Group::ArrayOfIndex({36, 37, 268, 48, 53, 52, 238, 35, 213, 338, 381, 344, 242, 267, 104, 306, 384, 321, 324, 322, 311, nstreams.isnull() ? Index(nstreams_default.pos()) : Group::Index(nstreams.pos()), pfct_method.isnull() ? Index(pfct_method_default.pos()) : Group::Index(pfct_method.pos()), ground_type.isnull() ? Index(ground_type_default.pos()) : Group::Index(ground_type.pos()), quad_type.isnull() ? Index(quad_type_default.pos()) : Group::Index(quad_type.pos()), add_straight_angles.isnull() ? Index(add_straight_angles_default.pos()) : Group::Index(add_straight_angles.pos()), pfct_aa_grid_size.isnull() ? Index(pfct_aa_grid_size_default.pos()) : Group::Index(pfct_aa_grid_size.pos()), auto_inc_nstreams.isnull() ? Index(auto_inc_nstreams_default.pos()) : Group::Index(auto_inc_nstreams.pos()), robust.isnull() ? Index(robust_default.pos()) : Group::Index(robust.pos()), za_interp_order.isnull() ? Index(za_interp_order_default.pos()) : Group::Index(za_interp_order.pos()), cos_za_interp.isnull() ? Index(cos_za_interp_default.pos()) : Group::Index(cos_za_interp.pos()), max_delta_tau.isnull() ? Index(max_delta_tau_default.pos()) : Group::Index(max_delta_tau.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord RT4Test(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 out_rad,

               const Var::String& datapath={}) {

  if (out_rad.islast()) {

    throw std::runtime_error("out_rad needs to be a defined WorkspaceTensor4 since it is output of RT4Test");

  } if (not datapath.isnull() and datapath.islast()) {

    throw std::runtime_error("datapath needs to be a defined WorkspaceString (or left default) since it is agenda input to RT4Test");

  }


  static const auto datapath_default = Var::StringCreate(ws, "artscomponents/polradtran/testdata/",

    "RT4Test_datapath_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1475,

    Group::ArrayOfIndex({Group::Index(out_rad.pos()), }),

    Group::ArrayOfIndex({datapath.isnull() ? Index(datapath_default.pos()) : Group::Index(datapath.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord rte_losGeometricFromRtePosToRtePos2(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1476,

    Group::ArrayOfIndex({257, }),

    Group::ArrayOfIndex({35, 139, 147, 250, 258, 259, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord rte_losSet(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric za,

               const Var::Numeric aa) {

  if (za.islast()) {

    throw std::runtime_error("za needs to be a defined WorkspaceNumeric since it is agenda input to rte_losSet");

  } if (aa.islast()) {

    throw std::runtime_error("aa needs to be a defined WorkspaceNumeric since it is agenda input to rte_losSet");

  }


  return MRecord(1477,

    Group::ArrayOfIndex({257, }),

    Group::ArrayOfIndex({35, Group::Index(za.pos()), Group::Index(aa.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord rte_posSet(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric z,

               const Var::Numeric lat,

               const Var::Numeric lon) {

  if (z.islast()) {

    throw std::runtime_error("z needs to be a defined WorkspaceNumeric since it is agenda input to rte_posSet");

  } if (lat.islast()) {

    throw std::runtime_error("lat needs to be a defined WorkspaceNumeric since it is agenda input to rte_posSet");

  } if (lon.islast()) {

    throw std::runtime_error("lon needs to be a defined WorkspaceNumeric since it is agenda input to rte_posSet");

  }


  return MRecord(1478,

    Group::ArrayOfIndex({258, }),

    Group::ArrayOfIndex({35, Group::Index(z.pos()), Group::Index(lat.pos()), Group::Index(lon.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord rte_pos_losMoveToStartOfPpath(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1479,

    Group::ArrayOfIndex({258, 257, }),

    Group::ArrayOfIndex({35, 216, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord rtp_nlteFromRaw(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector data) {

  if (data.islast()) {

    throw std::runtime_error("data needs to be a defined WorkspaceVector since it is agenda input to rtp_nlteFromRaw");

  }


  return MRecord(1480,

    Group::ArrayOfIndex({265, }),

    Group::ArrayOfIndex({179, 180, Group::Index(data.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ScatElementsPndAndScatAdd(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfString scat_data_files,

               const Var::ArrayOfString pnd_field_files) {

  if (scat_data_files.islast()) {

    throw std::runtime_error("scat_data_files needs to be a defined WorkspaceArrayOfString since it is agenda input to ScatElementsPndAndScatAdd");

  } if (pnd_field_files.islast()) {

    throw std::runtime_error("pnd_field_files needs to be a defined WorkspaceArrayOfString since it is agenda input to ScatElementsPndAndScatAdd");

  }


  return MRecord(1481,

    Group::ArrayOfIndex({269, 215, }),

    Group::ArrayOfIndex({35, Group::Index(scat_data_files.pos()), Group::Index(pnd_field_files.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ScatElementsSelect(

    [[maybe_unused]] Workspace& ws,

               const Var::String species,

               const Var::String sizeparam,

               const Var::Numeric& sizemin={},

               const Var::Numeric& sizemax={},

               const Var::Numeric& tolerance={},

               const Var::String& delim={}) {

  if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to ScatElementsSelect");

  } if (sizeparam.islast()) {

    throw std::runtime_error("sizeparam needs to be a defined WorkspaceString since it is agenda input to ScatElementsSelect");

  } if (not sizemin.isnull() and sizemin.islast()) {

    throw std::runtime_error("sizemin needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ScatElementsSelect");

  } if (not sizemax.isnull() and sizemax.islast()) {

    throw std::runtime_error("sizemax needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ScatElementsSelect");

  } if (not tolerance.isnull() and tolerance.islast()) {

    throw std::runtime_error("tolerance needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ScatElementsSelect");

  } if (not delim.isnull() and delim.islast()) {

    throw std::runtime_error("delim needs to be a defined WorkspaceString (or left default) since it is agenda input to ScatElementsSelect");

  }


  static const auto sizemin_default = Var::NumericCreate(ws, 0.,

    "ScatElementsSelect_sizemin_autodefault",

    "auto generated variable with default from method definition");

  static const auto sizemax_default = Var::NumericCreate(ws, -1.,

    "ScatElementsSelect_sizemax_autodefault",

    "auto generated variable with default from method definition");

  static const auto tolerance_default = Var::NumericCreate(ws, 1e-6,

    "ScatElementsSelect_tolerance_autodefault",

    "auto generated variable with default from method definition");

  static const auto delim_default = Var::StringCreate(ws, "-",

    "ScatElementsSelect_delim_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1482,

    Group::ArrayOfIndex({269, 275, }),

    Group::ArrayOfIndex({277, Group::Index(species.pos()), Group::Index(sizeparam.pos()), sizemin.isnull() ? Index(sizemin_default.pos()) : Group::Index(sizemin.pos()), sizemax.isnull() ? Index(sizemax_default.pos()) : Group::Index(sizemax.pos()), tolerance.isnull() ? Index(tolerance_default.pos()) : Group::Index(tolerance.pos()), delim.isnull() ? Index(delim_default.pos()) : Group::Index(delim.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ScatElementsToabs_speciesAdd(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfString scat_data_files,

               const Var::ArrayOfString pnd_field_files) {

  if (scat_data_files.islast()) {

    throw std::runtime_error("scat_data_files needs to be a defined WorkspaceArrayOfString since it is agenda input to ScatElementsToabs_speciesAdd");

  } if (pnd_field_files.islast()) {

    throw std::runtime_error("pnd_field_files needs to be a defined WorkspaceArrayOfString since it is agenda input to ScatElementsToabs_speciesAdd");

  }


  return MRecord(1483,

    Group::ArrayOfIndex({269, 345, 21, 237, 28, }),

    Group::ArrayOfIndex({35, 104, Group::Index(scat_data_files.pos()), Group::Index(pnd_field_files.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ScatSpeciesExtendTemperature(

    [[maybe_unused]] Workspace& ws,

               const Var::String& species={},

               const Var::String& scat_species_delim={},

               const Var::Numeric& T_low={},

               const Var::Numeric& T_high={}) {

  if (not species.isnull() and species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString (or left default) since it is agenda input to ScatSpeciesExtendTemperature");

  } if (not scat_species_delim.isnull() and scat_species_delim.islast()) {

    throw std::runtime_error("scat_species_delim needs to be a defined WorkspaceString (or left default) since it is agenda input to ScatSpeciesExtendTemperature");

  } if (not T_low.isnull() and T_low.islast()) {

    throw std::runtime_error("T_low needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ScatSpeciesExtendTemperature");

  } if (not T_high.isnull() and T_high.islast()) {

    throw std::runtime_error("T_high needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ScatSpeciesExtendTemperature");

  }


  static const auto species_default = Var::StringCreate(ws, "",

    "ScatSpeciesExtendTemperature_species_autodefault",

    "auto generated variable with default from method definition");

  static const auto scat_species_delim_default = Var::StringCreate(ws, "-",

    "ScatSpeciesExtendTemperature_scat_species_delim_autodefault",

    "auto generated variable with default from method definition");

  static const auto T_low_default = Var::NumericCreate(ws, -1.,

    "ScatSpeciesExtendTemperature_T_low_autodefault",

    "auto generated variable with default from method definition");

  static const auto T_high_default = Var::NumericCreate(ws, -1.,

    "ScatSpeciesExtendTemperature_T_high_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1484,

    Group::ArrayOfIndex({269, }),

    Group::ArrayOfIndex({277, species.isnull() ? Index(species_default.pos()) : Group::Index(species.pos()), scat_species_delim.isnull() ? Index(scat_species_delim_default.pos()) : Group::Index(scat_species_delim.pos()), T_low.isnull() ? Index(T_low_default.pos()) : Group::Index(T_low.pos()), T_high.isnull() ? Index(T_high_default.pos()) : Group::Index(T_high.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ScatSpeciesInit(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1485,

    Group::ArrayOfIndex({277, 269, 275, 268, 215, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ScatSpeciesMerge(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1486,

    Group::ArrayOfIndex({213, 267, 275, 277, 48, }),

    Group::ArrayOfIndex({35, 53, 52, 338, 381, 384, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ScatSpeciesPndAndScatAdd(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfString scat_data_files,

               const Var::String pnd_fieldarray_file) {

  if (scat_data_files.islast()) {

    throw std::runtime_error("scat_data_files needs to be a defined WorkspaceArrayOfString since it is agenda input to ScatSpeciesPndAndScatAdd");

  } if (pnd_fieldarray_file.islast()) {

    throw std::runtime_error("pnd_fieldarray_file needs to be a defined WorkspaceString since it is agenda input to ScatSpeciesPndAndScatAdd");

  }


  return MRecord(1487,

    Group::ArrayOfIndex({269, 215, }),

    Group::ArrayOfIndex({35, Group::Index(scat_data_files.pos()), Group::Index(pnd_fieldarray_file.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ScatSpeciesScatAndMetaRead(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfString scat_data_files) {

  if (scat_data_files.islast()) {

    throw std::runtime_error("scat_data_files needs to be a defined WorkspaceArrayOfString since it is agenda input to ScatSpeciesScatAndMetaRead");

  }


  return MRecord(1488,

    Group::ArrayOfIndex({269, 275, }),

    Group::ArrayOfIndex({Group::Index(scat_data_files.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord scat_data_singleTmatrix(

    [[maybe_unused]] Workspace& ws,

               const Var::String shape,

               const Var::Numeric diameter_volume_equ,

               const Var::Numeric aspect_ratio,

               const Var::String ptype,

               const Var::Vector data_f_grid,

               const Var::Vector data_t_grid,

               const Var::Vector data_za_grid,

               const Var::Numeric& mass={},

               const Var::Vector& data_aa_grid={},

               const Var::Numeric& precision={},

               const Var::String& cri_source={},

               const Var::Index& ndgs={},

               const Var::Index& robust={},

               const Var::Index& quiet={}) {

  if (shape.islast()) {

    throw std::runtime_error("shape needs to be a defined WorkspaceString since it is agenda input to scat_data_singleTmatrix");

  } if (diameter_volume_equ.islast()) {

    throw std::runtime_error("diameter_volume_equ needs to be a defined WorkspaceNumeric since it is agenda input to scat_data_singleTmatrix");

  } if (aspect_ratio.islast()) {

    throw std::runtime_error("aspect_ratio needs to be a defined WorkspaceNumeric since it is agenda input to scat_data_singleTmatrix");

  } if (not mass.isnull() and mass.islast()) {

    throw std::runtime_error("mass needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to scat_data_singleTmatrix");

  } if (ptype.islast()) {

    throw std::runtime_error("ptype needs to be a defined WorkspaceString since it is agenda input to scat_data_singleTmatrix");

  } if (data_f_grid.islast()) {

    throw std::runtime_error("data_f_grid needs to be a defined WorkspaceVector since it is agenda input to scat_data_singleTmatrix");

  } if (data_t_grid.islast()) {

    throw std::runtime_error("data_t_grid needs to be a defined WorkspaceVector since it is agenda input to scat_data_singleTmatrix");

  } if (data_za_grid.islast()) {

    throw std::runtime_error("data_za_grid needs to be a defined WorkspaceVector since it is agenda input to scat_data_singleTmatrix");

  } if (not data_aa_grid.isnull() and data_aa_grid.islast()) {

    throw std::runtime_error("data_aa_grid needs to be a defined WorkspaceVector (or left default) since it is agenda input to scat_data_singleTmatrix");

  } if (not precision.isnull() and precision.islast()) {

    throw std::runtime_error("precision needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to scat_data_singleTmatrix");

  } if (not cri_source.isnull() and cri_source.islast()) {

    throw std::runtime_error("cri_source needs to be a defined WorkspaceString (or left default) since it is agenda input to scat_data_singleTmatrix");

  } if (not ndgs.isnull() and ndgs.islast()) {

    throw std::runtime_error("ndgs needs to be a defined WorkspaceIndex (or left default) since it is agenda input to scat_data_singleTmatrix");

  } if (not robust.isnull() and robust.islast()) {

    throw std::runtime_error("robust needs to be a defined WorkspaceIndex (or left default) since it is agenda input to scat_data_singleTmatrix");

  } if (not quiet.isnull() and quiet.islast()) {

    throw std::runtime_error("quiet needs to be a defined WorkspaceIndex (or left default) since it is agenda input to scat_data_singleTmatrix");

  }


  static const auto mass_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::quiet_NaN(),

    "scat_data_singleTmatrix_mass_autodefault",

    "auto generated variable with default from method definition");

  static const auto data_aa_grid_default = Var::VectorCreate(ws, {},

    "scat_data_singleTmatrix_data_aa_grid_autodefault",

    "auto generated variable with default from method definition");

  static const auto precision_default = Var::NumericCreate(ws, 0.001,

    "scat_data_singleTmatrix_precision_autodefault",

    "auto generated variable with default from method definition");

  static const auto cri_source_default = Var::StringCreate(ws, "Set by user, unknown source.",

    "scat_data_singleTmatrix_cri_source_autodefault",

    "auto generated variable with default from method definition");

  static const auto ndgs_default = Var::IndexCreate(ws, 2,

    "scat_data_singleTmatrix_ndgs_autodefault",

    "auto generated variable with default from method definition");

  static const auto robust_default = Var::IndexCreate(ws, 0,

    "scat_data_singleTmatrix_robust_autodefault",

    "auto generated variable with default from method definition");

  static const auto quiet_default = Var::IndexCreate(ws, 1,

    "scat_data_singleTmatrix_quiet_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1489,

    Group::ArrayOfIndex({271, 274, }),

    Group::ArrayOfIndex({54, Group::Index(shape.pos()), Group::Index(diameter_volume_equ.pos()), Group::Index(aspect_ratio.pos()), mass.isnull() ? Index(mass_default.pos()) : Group::Index(mass.pos()), Group::Index(ptype.pos()), Group::Index(data_f_grid.pos()), Group::Index(data_t_grid.pos()), Group::Index(data_za_grid.pos()), data_aa_grid.isnull() ? Index(data_aa_grid_default.pos()) : Group::Index(data_aa_grid.pos()), precision.isnull() ? Index(precision_default.pos()) : Group::Index(precision.pos()), cri_source.isnull() ? Index(cri_source_default.pos()) : Group::Index(cri_source.pos()), ndgs.isnull() ? Index(ndgs_default.pos()) : Group::Index(ndgs.pos()), robust.isnull() ? Index(robust_default.pos()) : Group::Index(robust.pos()), quiet.isnull() ? Index(quiet_default.pos()) : Group::Index(quiet.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord scat_data_checkedCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& dfrel_threshold={},

               const Var::String& check_level={},

               const Var::Numeric& sca_mat_threshold={}) {

  if (not dfrel_threshold.isnull() and dfrel_threshold.islast()) {

    throw std::runtime_error("dfrel_threshold needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to scat_data_checkedCalc");

  } if (not check_level.isnull() and check_level.islast()) {

    throw std::runtime_error("check_level needs to be a defined WorkspaceString (or left default) since it is agenda input to scat_data_checkedCalc");

  } if (not sca_mat_threshold.isnull() and sca_mat_threshold.islast()) {

    throw std::runtime_error("sca_mat_threshold needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to scat_data_checkedCalc");

  }


  static const auto dfrel_threshold_default = Var::NumericCreate(ws, 0.1,

    "scat_data_checkedCalc_dfrel_threshold_autodefault",

    "auto generated variable with default from method definition");

  static const auto check_level_default = Var::StringCreate(ws, "all",

    "scat_data_checkedCalc_check_level_autodefault",

    "auto generated variable with default from method definition");

  static const auto sca_mat_threshold_default = Var::NumericCreate(ws, 5e-2,

    "scat_data_checkedCalc_sca_mat_threshold_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1490,

    Group::ArrayOfIndex({268, }),

    Group::ArrayOfIndex({267, 104, dfrel_threshold.isnull() ? Index(dfrel_threshold_default.pos()) : Group::Index(dfrel_threshold.pos()), check_level.isnull() ? Index(check_level_default.pos()) : Group::Index(check_level.pos()), sca_mat_threshold.isnull() ? Index(sca_mat_threshold_default.pos()) : Group::Index(sca_mat_threshold.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord scat_data_monoCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1491,

    Group::ArrayOfIndex({270, }),

    Group::ArrayOfIndex({267, 104, 105, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord scat_data_monoExtract(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1492,

    Group::ArrayOfIndex({270, }),

    Group::ArrayOfIndex({267, 105, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord scat_dataCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& interp_order={}) {

  if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to scat_dataCalc");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "scat_dataCalc_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1493,

    Group::ArrayOfIndex({267, }),

    Group::ArrayOfIndex({269, 104, interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord scat_dataCheck(

    [[maybe_unused]] Workspace& ws,

               const Var::String& check_type={},

               const Var::Numeric& sca_mat_threshold={}) {

  if (not check_type.isnull() and check_type.islast()) {

    throw std::runtime_error("check_type needs to be a defined WorkspaceString (or left default) since it is agenda input to scat_dataCheck");

  } if (not sca_mat_threshold.isnull() and sca_mat_threshold.islast()) {

    throw std::runtime_error("sca_mat_threshold needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to scat_dataCheck");

  }


  static const auto check_type_default = Var::StringCreate(ws, "all",

    "scat_dataCheck_check_type_autodefault",

    "auto generated variable with default from method definition");

  static const auto sca_mat_threshold_default = Var::NumericCreate(ws, 5e-2,

    "scat_dataCheck_sca_mat_threshold_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1494,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({267, check_type.isnull() ? Index(check_type_default.pos()) : Group::Index(check_type.pos()), sca_mat_threshold.isnull() ? Index(sca_mat_threshold_default.pos()) : Group::Index(sca_mat_threshold.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord scat_dataReduceT(

    [[maybe_unused]] Workspace& ws,

               const Var::Index scat_index,

               const Var::Numeric temperature,

               const Var::Index& interp_order={},

               const Var::Index& phamat_only={},

               const Var::Numeric& sca_mat_threshold={}) {

  if (scat_index.islast()) {

    throw std::runtime_error("scat_index needs to be a defined WorkspaceIndex since it is agenda input to scat_dataReduceT");

  } if (temperature.islast()) {

    throw std::runtime_error("temperature needs to be a defined WorkspaceNumeric since it is agenda input to scat_dataReduceT");

  } if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to scat_dataReduceT");

  } if (not phamat_only.isnull() and phamat_only.islast()) {

    throw std::runtime_error("phamat_only needs to be a defined WorkspaceIndex (or left default) since it is agenda input to scat_dataReduceT");

  } if (not sca_mat_threshold.isnull() and sca_mat_threshold.islast()) {

    throw std::runtime_error("sca_mat_threshold needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to scat_dataReduceT");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "scat_dataReduceT_interp_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto phamat_only_default = Var::IndexCreate(ws, 1,

    "scat_dataReduceT_phamat_only_autodefault",

    "auto generated variable with default from method definition");

  static const auto sca_mat_threshold_default = Var::NumericCreate(ws, 5e-2,

    "scat_dataReduceT_sca_mat_threshold_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1495,

    Group::ArrayOfIndex({267, }),

    Group::ArrayOfIndex({Group::Index(scat_index.pos()), Group::Index(temperature.pos()), interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), phamat_only.isnull() ? Index(phamat_only_default.pos()) : Group::Index(phamat_only.pos()), sca_mat_threshold.isnull() ? Index(sca_mat_threshold_default.pos()) : Group::Index(sca_mat_threshold.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ScatSpeciesSizeMassInfo(

    [[maybe_unused]] Workspace& ws,

               const Var::Index species_index,

               const Var::String x_unit,

               const Var::Numeric& x_fit_start={},

               const Var::Numeric& x_fit_end={},

               const Var::Index& do_only_x={}) {

  if (species_index.islast()) {

    throw std::runtime_error("species_index needs to be a defined WorkspaceIndex since it is agenda input to ScatSpeciesSizeMassInfo");

  } if (x_unit.islast()) {

    throw std::runtime_error("x_unit needs to be a defined WorkspaceString since it is agenda input to ScatSpeciesSizeMassInfo");

  } if (not x_fit_start.isnull() and x_fit_start.islast()) {

    throw std::runtime_error("x_fit_start needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ScatSpeciesSizeMassInfo");

  } if (not x_fit_end.isnull() and x_fit_end.islast()) {

    throw std::runtime_error("x_fit_end needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ScatSpeciesSizeMassInfo");

  } if (not do_only_x.isnull() and do_only_x.islast()) {

    throw std::runtime_error("do_only_x needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ScatSpeciesSizeMassInfo");

  }


  static const auto x_fit_start_default = Var::NumericCreate(ws, 0,

    "ScatSpeciesSizeMassInfo_x_fit_start_autodefault",

    "auto generated variable with default from method definition");

  static const auto x_fit_end_default = Var::NumericCreate(ws, 1e9,

    "ScatSpeciesSizeMassInfo_x_fit_end_autodefault",

    "auto generated variable with default from method definition");

  static const auto do_only_x_default = Var::IndexCreate(ws, 0,

    "ScatSpeciesSizeMassInfo_do_only_x_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1496,

    Group::ArrayOfIndex({280, 278, 279, }),

    Group::ArrayOfIndex({275, Group::Index(species_index.pos()), Group::Index(x_unit.pos()), x_fit_start.isnull() ? Index(x_fit_start_default.pos()) : Group::Index(x_fit_start.pos()), x_fit_end.isnull() ? Index(x_fit_end_default.pos()) : Group::Index(x_fit_end.pos()), do_only_x.isnull() ? Index(do_only_x_default.pos()) : Group::Index(do_only_x.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord particle_fieldCleanup(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 particle_field_out,

               const Var::Tensor4 particle_field_in,

               const Var::Numeric threshold) {

  if (particle_field_out.islast()) {

    throw std::runtime_error("particle_field_out needs to be a defined WorkspaceTensor4 since it is output of particle_fieldCleanup");

  } if (particle_field_in.islast()) {

    throw std::runtime_error("particle_field_in needs to be a defined WorkspaceTensor4 since it is agenda input to particle_fieldCleanup");

  } if (threshold.islast()) {

    throw std::runtime_error("threshold needs to be a defined WorkspaceNumeric since it is agenda input to particle_fieldCleanup");

  }


  return MRecord(1497,

    Group::ArrayOfIndex({Group::Index(particle_field_out.pos()), }),

    Group::ArrayOfIndex({Group::Index(particle_field_in.pos()), Group::Index(threshold.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfAbsorptionLines needles,

               const Var::ArrayOfAbsorptionLines haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfAbsorptionLines since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfAbsorptionLines since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1498,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfAbsorptionLines needles,

               const Var::ArrayOfArrayOfAbsorptionLines haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1499,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfAgenda needles,

               const Var::ArrayOfAgenda haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfAgenda since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfAgenda since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1500,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField1 needles,

               const Var::ArrayOfArrayOfGriddedField1 haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1501,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField2 needles,

               const Var::ArrayOfArrayOfGriddedField2 haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1502,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField3 needles,

               const Var::ArrayOfArrayOfGriddedField3 haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1503,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfIndex needles,

               const Var::ArrayOfArrayOfIndex haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfIndex since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfIndex since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1504,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfMatrix needles,

               const Var::ArrayOfArrayOfMatrix haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1505,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfPpath needles,

               const Var::ArrayOfPpath haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfPpath since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfPpath since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1506,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfPropagationMatrix needles,

               const Var::ArrayOfArrayOfPropagationMatrix haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1507,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfRadiationVector needles,

               const Var::ArrayOfArrayOfRadiationVector haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1508,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfScatteringMetaData needles,

               const Var::ArrayOfArrayOfScatteringMetaData haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1509,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfSingleScatteringData needles,

               const Var::ArrayOfArrayOfSingleScatteringData haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1510,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfSpeciesTag needles,

               const Var::ArrayOfArrayOfSpeciesTag haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1511,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfStokesVector needles,

               const Var::ArrayOfArrayOfStokesVector haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1512,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfString needles,

               const Var::ArrayOfArrayOfString haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfString since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfString since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1513,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTensor3 needles,

               const Var::ArrayOfArrayOfTensor3 haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1514,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTensor6 needles,

               const Var::ArrayOfArrayOfTensor6 haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1515,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTime needles,

               const Var::ArrayOfArrayOfTime haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfTime since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfTime since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1516,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTransmissionMatrix needles,

               const Var::ArrayOfArrayOfTransmissionMatrix haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1517,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfVector needles,

               const Var::ArrayOfArrayOfVector haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfArrayOfVector since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfArrayOfVector since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1518,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfCIARecord needles,

               const Var::ArrayOfCIARecord haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfCIARecord since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfCIARecord since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1519,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField1 needles,

               const Var::ArrayOfGriddedField1 haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfGriddedField1 since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfGriddedField1 since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1520,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField2 needles,

               const Var::ArrayOfGriddedField2 haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfGriddedField2 since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfGriddedField2 since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1521,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField3 needles,

               const Var::ArrayOfGriddedField3 haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1522,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField4 needles,

               const Var::ArrayOfGriddedField4 haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfGriddedField4 since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfGriddedField4 since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1523,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfIndex needles,

               const Var::ArrayOfIndex haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfIndex since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1524,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfMatrix needles,

               const Var::ArrayOfMatrix haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfMatrix since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1525,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfPropagationMatrix needles,

               const Var::ArrayOfPropagationMatrix haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfPropagationMatrix since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfPropagationMatrix since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1526,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfQuantumIdentifier needles,

               const Var::ArrayOfQuantumIdentifier haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1527,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfRadiationVector needles,

               const Var::ArrayOfRadiationVector haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfRadiationVector since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfRadiationVector since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1528,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfRetrievalQuantity needles,

               const Var::ArrayOfRetrievalQuantity haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1529,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfScatteringMetaData needles,

               const Var::ArrayOfScatteringMetaData haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfScatteringMetaData since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfScatteringMetaData since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1530,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSingleScatteringData needles,

               const Var::ArrayOfSingleScatteringData haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfSingleScatteringData since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1531,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSparse needles,

               const Var::ArrayOfSparse haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfSparse since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfSparse since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1532,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfStokesVector needles,

               const Var::ArrayOfStokesVector haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfStokesVector since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfStokesVector since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1533,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfString needles,

               const Var::ArrayOfString haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfString since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfString since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1534,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTelsemAtlas needles,

               const Var::ArrayOfTelsemAtlas haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTelsemAtlas since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfTelsemAtlas since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1535,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor3 needles,

               const Var::ArrayOfTensor3 haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTensor3 since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfTensor3 since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1536,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor4 needles,

               const Var::ArrayOfTensor4 haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTensor4 since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfTensor4 since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1537,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor5 needles,

               const Var::ArrayOfTensor5 haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTensor5 since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfTensor5 since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1538,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor6 needles,

               const Var::ArrayOfTensor6 haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTensor6 since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfTensor6 since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1539,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor7 needles,

               const Var::ArrayOfTensor7 haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTensor7 since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfTensor7 since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1540,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTime needles,

               const Var::ArrayOfTime haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTime since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfTime since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1541,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTransmissionMatrix needles,

               const Var::ArrayOfTransmissionMatrix haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1542,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfVector needles,

               const Var::ArrayOfVector haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfVector since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfVector since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1543,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfXsecRecord needles,

               const Var::ArrayOfXsecRecord haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceArrayOfXsecRecord since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceArrayOfXsecRecord since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1544,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector needles,

               const Var::Vector haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceVector since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceVector since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1545,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix needles,

               const Var::Matrix haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceMatrix since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceMatrix since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1546,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Select(

    [[maybe_unused]] Workspace& ws,

                     Var::Sparse needles,

               const Var::Sparse haystack,

               const Var::ArrayOfIndex needleindexes) {

  if (needles.islast()) {

    throw std::runtime_error("needles needs to be a defined WorkspaceSparse since it is output of Select");

  } if (haystack.islast()) {

    throw std::runtime_error("haystack needs to be a defined WorkspaceSparse since it is agenda input to Select");

  } if (needleindexes.islast()) {

    throw std::runtime_error("needleindexes needs to be a defined WorkspaceArrayOfIndex since it is agenda input to Select");

  }


  return MRecord(1547,

    Group::ArrayOfIndex({Group::Index(needles.pos()), }),

    Group::ArrayOfIndex({Group::Index(haystack.pos()), Group::Index(needleindexes.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_checkedCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1548,

    Group::ArrayOfIndex({281, }),

    Group::ArrayOfIndex({35, 306, 104, 286, 283, 337, 156, 287, 292, 294, 290, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensorOff(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1549,

    Group::ArrayOfIndex({287, 292, 294, 290, 293, 295, 291, 156, }),

    Group::ArrayOfIndex({306, 104, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_losGeometricFromSensorPosToOtherPositions(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix target_pos) {

  if (target_pos.islast()) {

    throw std::runtime_error("target_pos needs to be a defined WorkspaceMatrix since it is agenda input to sensor_losGeometricFromSensorPosToOtherPositions");

  }


  return MRecord(1550,

    Group::ArrayOfIndex({283, }),

    Group::ArrayOfIndex({35, 139, 147, 250, 286, Group::Index(target_pos.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseAntenna(

    [[maybe_unused]] Workspace& ws,

               const Var::String& option_2d={}) {

  if (not option_2d.isnull() and option_2d.islast()) {

    throw std::runtime_error("option_2d needs to be a defined WorkspaceString (or left default) since it is agenda input to sensor_responseAntenna");

  }


  static const auto option_2d_default = Var::StringCreate(ws, "-",

    "sensor_responseAntenna_option_2d_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1551,

    Group::ArrayOfIndex({287, 292, 294, 290, 291, }),

    Group::ArrayOfIndex({293, 295, 35, 32, 33, 34, 284, option_2d.isnull() ? Index(option_2d_default.pos()) : Group::Index(option_2d.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseBackend(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1552,

    Group::ArrayOfIndex({287, 292, 294, 290, 293, }),

    Group::ArrayOfIndex({295, 291, 102, 40, 284, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseBackendFrequencySwitching(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric df1,

               const Var::Numeric df2) {

  if (df1.islast()) {

    throw std::runtime_error("df1 needs to be a defined WorkspaceNumeric since it is agenda input to sensor_responseBackendFrequencySwitching");

  } if (df2.islast()) {

    throw std::runtime_error("df2 needs to be a defined WorkspaceNumeric since it is agenda input to sensor_responseBackendFrequencySwitching");

  }


  return MRecord(1553,

    Group::ArrayOfIndex({287, 292, 294, 290, 293, }),

    Group::ArrayOfIndex({295, 291, 102, 40, 284, Group::Index(df1.pos()), Group::Index(df2.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseBeamSwitching(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& w1={},

               const Var::Numeric& w2={}) {

  if (not w1.isnull() and w1.islast()) {

    throw std::runtime_error("w1 needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to sensor_responseBeamSwitching");

  } if (not w2.isnull() and w2.islast()) {

    throw std::runtime_error("w2 needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to sensor_responseBeamSwitching");

  }


  static const auto w1_default = Var::NumericCreate(ws, -1,

    "sensor_responseBeamSwitching_w1_autodefault",

    "auto generated variable with default from method definition");

  static const auto w2_default = Var::NumericCreate(ws, 1,

    "sensor_responseBeamSwitching_w2_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1554,

    Group::ArrayOfIndex({287, 292, 294, 290, 291, }),

    Group::ArrayOfIndex({293, 295, w1.isnull() ? Index(w1_default.pos()) : Group::Index(w1.pos()), w2.isnull() ? Index(w2_default.pos()) : Group::Index(w2.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseFillFgrid(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& polyorder={},

               const Var::Index& nfill={}) {

  if (not polyorder.isnull() and polyorder.islast()) {

    throw std::runtime_error("polyorder needs to be a defined WorkspaceIndex (or left default) since it is agenda input to sensor_responseFillFgrid");

  } if (not nfill.isnull() and nfill.islast()) {

    throw std::runtime_error("nfill needs to be a defined WorkspaceIndex (or left default) since it is agenda input to sensor_responseFillFgrid");

  }


  static const auto polyorder_default = Var::IndexCreate(ws, 3,

    "sensor_responseFillFgrid_polyorder_autodefault",

    "auto generated variable with default from method definition");

  static const auto nfill_default = Var::IndexCreate(ws, 2,

    "sensor_responseFillFgrid_nfill_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1555,

    Group::ArrayOfIndex({287, 292, 294, 290, 293, }),

    Group::ArrayOfIndex({295, 291, polyorder.isnull() ? Index(polyorder_default.pos()) : Group::Index(polyorder.pos()), nfill.isnull() ? Index(nfill_default.pos()) : Group::Index(nfill.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseFrequencySwitching(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1556,

    Group::ArrayOfIndex({287, 292, 294, 290, 293, }),

    Group::ArrayOfIndex({295, 291, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseIF2RF(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1557,

    Group::ArrayOfIndex({292, 293, }),

    Group::ArrayOfIndex({144, 297, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseInit(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1558,

    Group::ArrayOfIndex({287, 292, 294, 290, 293, 295, 291, }),

    Group::ArrayOfIndex({104, 156, 32, 35, 306, 284, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseMetMM(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& use_antenna={},

               const Var::Index& mirror_dza={}) {

  if (not use_antenna.isnull() and use_antenna.islast()) {

    throw std::runtime_error("use_antenna needs to be a defined WorkspaceIndex (or left default) since it is agenda input to sensor_responseMetMM");

  } if (not mirror_dza.isnull() and mirror_dza.islast()) {

    throw std::runtime_error("mirror_dza needs to be a defined WorkspaceIndex (or left default) since it is agenda input to sensor_responseMetMM");

  }


  static const auto use_antenna_default = Var::IndexCreate(ws, 0,

    "sensor_responseMetMM_use_antenna_autodefault",

    "auto generated variable with default from method definition");

  static const auto mirror_dza_default = Var::IndexCreate(ws, 0,

    "sensor_responseMetMM_mirror_dza_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1559,

    Group::ArrayOfIndex({32, 156, 287, 292, 294, 290, 293, 295, 291, 284, }),

    Group::ArrayOfIndex({35, 306, 104, 102, 46, 47, 133, 33, 175, 173, use_antenna.isnull() ? Index(use_antenna_default.pos()) : Group::Index(use_antenna.pos()), mirror_dza.isnull() ? Index(mirror_dza_default.pos()) : Group::Index(mirror_dza.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseMixer(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1560,

    Group::ArrayOfIndex({287, 292, 294, 290, 293, }),

    Group::ArrayOfIndex({295, 291, 144, 299, 284, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseMixerBackendPrecalcWeights(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1561,

    Group::ArrayOfIndex({287, 292, 294, 290, 293, }),

    Group::ArrayOfIndex({295, 291, 102, 46, 47, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseMultiMixerBackend(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1562,

    Group::ArrayOfIndex({287, 292, 294, 290, 293, }),

    Group::ArrayOfIndex({295, 291, 145, 300, 298, 103, 41, 284, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responsePolarisation(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1563,

    Group::ArrayOfIndex({287, 292, 294, 290, 295, }),

    Group::ArrayOfIndex({293, 291, 306, 133, 112, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseStokesRotation(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1564,

    Group::ArrayOfIndex({287, }),

    Group::ArrayOfIndex({293, 295, 291, 306, 310, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseSimpleAMSU(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& spacing={}) {

  if (not spacing.isnull() and spacing.islast()) {

    throw std::runtime_error("spacing needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to sensor_responseSimpleAMSU");

  }


  static const auto spacing_default = Var::NumericCreate(ws, .1e9,

    "sensor_responseSimpleAMSU_spacing_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1565,

    Group::ArrayOfIndex({104, 32, 156, 287, 292, 294, 290, 293, 295, 291, 284, }),

    Group::ArrayOfIndex({35, 306, 282, spacing.isnull() ? Index(spacing_default.pos()) : Group::Index(spacing.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseGenericAMSU(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& spacing={}) {

  if (not spacing.isnull() and spacing.islast()) {

    throw std::runtime_error("spacing needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to sensor_responseGenericAMSU");

  }


  static const auto spacing_default = Var::NumericCreate(ws, .1e9,

    "sensor_responseGenericAMSU_spacing_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1566,

    Group::ArrayOfIndex({104, 32, 156, 287, 292, 294, 290, 293, 295, 291, 284, }),

    Group::ArrayOfIndex({35, 306, 282, spacing.isnull() ? Index(spacing_default.pos()) : Group::Index(spacing.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord sensor_responseWMRF(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1567,

    Group::ArrayOfIndex({287, 292, 294, 290, 293, }),

    Group::ArrayOfIndex({295, 291, 356, 102, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord SetNumberOfThreads(

    [[maybe_unused]] Workspace& ws,

               const Var::Index nthreads) {

  if (nthreads.islast()) {

    throw std::runtime_error("nthreads needs to be a defined WorkspaceIndex since it is agenda input to SetNumberOfThreads");

  }


  return MRecord(1568,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(nthreads.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Sleep(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric time) {

  if (time.islast()) {

    throw std::runtime_error("time needs to be a defined WorkspaceNumeric since it is agenda input to Sleep");

  }


  return MRecord(1569,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(time.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord timeSleep(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1570,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({333, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord SparseSparseMultiply(

    [[maybe_unused]] Workspace& ws,

                     Var::Sparse out,

               const Var::Sparse m1,

               const Var::Sparse m2) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of SparseSparseMultiply");

  } if (m1.islast()) {

    throw std::runtime_error("m1 needs to be a defined WorkspaceSparse since it is agenda input to SparseSparseMultiply");

  } if (m2.islast()) {

    throw std::runtime_error("m2 needs to be a defined WorkspaceSparse since it is agenda input to SparseSparseMultiply");

  }


  return MRecord(1571,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(m1.pos()), Group::Index(m2.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord SparseMatrixIdentity(

    [[maybe_unused]] Workspace& ws,

                     Var::Sparse out,

               const Var::Index n,

               const Var::Numeric& value={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceSparse since it is output of SparseMatrixIdentity");

  } if (n.islast()) {

    throw std::runtime_error("n needs to be a defined WorkspaceIndex since it is agenda input to SparseMatrixIdentity");

  } if (not value.isnull() and value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to SparseMatrixIdentity");

  }


  static const auto value_default = Var::NumericCreate(ws, 1,

    "SparseMatrixIdentity_value_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1572,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(n.pos()), value.isnull() ? Index(value_default.pos()) : Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord spectral_irradiance_fieldFromSpectralRadianceField(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1573,

    Group::ArrayOfIndex({301, }),

    Group::ArrayOfIndex({302, 378, 0, 379, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord spectral_radiance_fieldClearskyPlaneParallel(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 trans_field,

               const Var::Index& use_parallel_iy={}) {

  if (trans_field.islast()) {

    throw std::runtime_error("trans_field needs to be a defined WorkspaceTensor3 since it is output of spectral_radiance_fieldClearskyPlaneParallel");

  } if (not use_parallel_iy.isnull() and use_parallel_iy.islast()) {

    throw std::runtime_error("use_parallel_iy needs to be a defined WorkspaceIndex (or left default) since it is agenda input to spectral_radiance_fieldClearskyPlaneParallel");

  }


  static const auto use_parallel_iy_default = Var::IndexCreate(ws, 0,

    "spectral_radiance_fieldClearskyPlaneParallel_use_parallel_iy_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1574,

    Group::ArrayOfIndex({302, Group::Index(trans_field.pos()), }),

    Group::ArrayOfIndex({238, 346, 128, 129, 123, 306, 104, 35, 242, 381, 338, 339, 344, 21, 349, 351, 353, 149, 151, 153, 384, 220, 256, 315, 378, use_parallel_iy.isnull() ? Index(use_parallel_iy_default.pos()) : Group::Index(use_parallel_iy.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord spectral_radiance_fieldCopyCloudboxField(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1575,

    Group::ArrayOfIndex({302, }),

    Group::ArrayOfIndex({35, 242, 53, 52, 49, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord spectral_radiance_fieldExpandCloudboxField(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& use_parallel_iy={}) {

  if (not use_parallel_iy.isnull() and use_parallel_iy.islast()) {

    throw std::runtime_error("use_parallel_iy needs to be a defined WorkspaceIndex (or left default) since it is agenda input to spectral_radiance_fieldExpandCloudboxField");

  }


  static const auto use_parallel_iy_default = Var::IndexCreate(ws, 0,

    "spectral_radiance_fieldExpandCloudboxField_use_parallel_iy_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1576,

    Group::ArrayOfIndex({302, }),

    Group::ArrayOfIndex({238, 346, 128, 129, 123, 306, 104, 35, 242, 381, 338, 339, 344, 21, 349, 351, 353, 149, 151, 153, 384, 53, 52, 49, 220, 256, 315, 378, use_parallel_iy.isnull() ? Index(use_parallel_iy_default.pos()) : Group::Index(use_parallel_iy.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord specular_losCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& ignore_surface_slope={}) {

  if (not ignore_surface_slope.isnull() and ignore_surface_slope.islast()) {

    throw std::runtime_error("ignore_surface_slope needs to be a defined WorkspaceIndex (or left default) since it is agenda input to specular_losCalc");

  }


  static const auto ignore_surface_slope_default = Var::IndexCreate(ws, 0,

    "specular_losCalc_ignore_surface_slope_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1577,

    Group::ArrayOfIndex({304, 314, }),

    Group::ArrayOfIndex({262, 261, 35, 139, 147, 250, 384, ignore_surface_slope.isnull() ? Index(ignore_surface_slope_default.pos()) : Group::Index(ignore_surface_slope.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord specular_losCalcNoTopography(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1578,

    Group::ArrayOfIndex({304, 314, }),

    Group::ArrayOfIndex({262, 261, 35, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord StringJoin(

    [[maybe_unused]] Workspace& ws,

                     Var::String out,

               const Var::String in1,

               const Var::String in2,

               const Var::String& in3={},

               const Var::String& in4={},

               const Var::String& in5={},

               const Var::String& in6={},

               const Var::String& in7={},

               const Var::String& in8={},

               const Var::String& in9={},

               const Var::String& in10={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceString since it is output of StringJoin");

  } if (in1.islast()) {

    throw std::runtime_error("in1 needs to be a defined WorkspaceString since it is agenda input to StringJoin");

  } if (in2.islast()) {

    throw std::runtime_error("in2 needs to be a defined WorkspaceString since it is agenda input to StringJoin");

  } if (not in3.isnull() and in3.islast()) {

    throw std::runtime_error("in3 needs to be a defined WorkspaceString (or left default) since it is agenda input to StringJoin");

  } if (not in4.isnull() and in4.islast()) {

    throw std::runtime_error("in4 needs to be a defined WorkspaceString (or left default) since it is agenda input to StringJoin");

  } if (not in5.isnull() and in5.islast()) {

    throw std::runtime_error("in5 needs to be a defined WorkspaceString (or left default) since it is agenda input to StringJoin");

  } if (not in6.isnull() and in6.islast()) {

    throw std::runtime_error("in6 needs to be a defined WorkspaceString (or left default) since it is agenda input to StringJoin");

  } if (not in7.isnull() and in7.islast()) {

    throw std::runtime_error("in7 needs to be a defined WorkspaceString (or left default) since it is agenda input to StringJoin");

  } if (not in8.isnull() and in8.islast()) {

    throw std::runtime_error("in8 needs to be a defined WorkspaceString (or left default) since it is agenda input to StringJoin");

  } if (not in9.isnull() and in9.islast()) {

    throw std::runtime_error("in9 needs to be a defined WorkspaceString (or left default) since it is agenda input to StringJoin");

  } if (not in10.isnull() and in10.islast()) {

    throw std::runtime_error("in10 needs to be a defined WorkspaceString (or left default) since it is agenda input to StringJoin");

  }


  static const auto in3_default = Var::StringCreate(ws, "",

    "StringJoin_in3_autodefault",

    "auto generated variable with default from method definition");

  static const auto in4_default = Var::StringCreate(ws, "",

    "StringJoin_in4_autodefault",

    "auto generated variable with default from method definition");

  static const auto in5_default = Var::StringCreate(ws, "",

    "StringJoin_in5_autodefault",

    "auto generated variable with default from method definition");

  static const auto in6_default = Var::StringCreate(ws, "",

    "StringJoin_in6_autodefault",

    "auto generated variable with default from method definition");

  static const auto in7_default = Var::StringCreate(ws, "",

    "StringJoin_in7_autodefault",

    "auto generated variable with default from method definition");

  static const auto in8_default = Var::StringCreate(ws, "",

    "StringJoin_in8_autodefault",

    "auto generated variable with default from method definition");

  static const auto in9_default = Var::StringCreate(ws, "",

    "StringJoin_in9_autodefault",

    "auto generated variable with default from method definition");

  static const auto in10_default = Var::StringCreate(ws, "",

    "StringJoin_in10_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1579,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in1.pos()), Group::Index(in2.pos()), in3.isnull() ? Index(in3_default.pos()) : Group::Index(in3.pos()), in4.isnull() ? Index(in4_default.pos()) : Group::Index(in4.pos()), in5.isnull() ? Index(in5_default.pos()) : Group::Index(in5.pos()), in6.isnull() ? Index(in6_default.pos()) : Group::Index(in6.pos()), in7.isnull() ? Index(in7_default.pos()) : Group::Index(in7.pos()), in8.isnull() ? Index(in8_default.pos()) : Group::Index(in8.pos()), in9.isnull() ? Index(in9_default.pos()) : Group::Index(in9.pos()), in10.isnull() ? Index(in10_default.pos()) : Group::Index(in10.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord StringSet(

    [[maybe_unused]] Workspace& ws,

                     Var::String out,

               const Var::String text) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceString since it is output of StringSet");

  } if (text.islast()) {

    throw std::runtime_error("text needs to be a defined WorkspaceString since it is agenda input to StringSet");

  }


  return MRecord(1580,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(text.pos()), }),

    TokVal{text.value()}, Agenda{});

}


[[nodiscard]] inline

MRecord z_surfaceFromFileAndGrid(

    [[maybe_unused]] Workspace& ws,

               const Var::String filename,

               const Var::Index& interp_order={},

               const Var::Index& set_lowest_altitude_to_zero={}) {

  if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to z_surfaceFromFileAndGrid");

  } if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to z_surfaceFromFileAndGrid");

  } if (not set_lowest_altitude_to_zero.isnull() and set_lowest_altitude_to_zero.islast()) {

    throw std::runtime_error("set_lowest_altitude_to_zero needs to be a defined WorkspaceIndex (or left default) since it is agenda input to z_surfaceFromFileAndGrid");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "z_surfaceFromFileAndGrid_interp_order_autodefault",

    "auto generated variable with default from method definition");

  static const auto set_lowest_altitude_to_zero_default = Var::IndexCreate(ws, 0,

    "z_surfaceFromFileAndGrid_set_lowest_altitude_to_zero_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1581,

    Group::ArrayOfIndex({384, }),

    Group::ArrayOfIndex({139, 147, Group::Index(filename.pos()), interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), set_lowest_altitude_to_zero.isnull() ? Index(set_lowest_altitude_to_zero_default.pos()) : Group::Index(set_lowest_altitude_to_zero.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord z_surfaceConstantAltitude(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& altitude={}) {

  if (not altitude.isnull() and altitude.islast()) {

    throw std::runtime_error("altitude needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to z_surfaceConstantAltitude");

  }


  static const auto altitude_default = Var::NumericCreate(ws, 0,

    "z_surfaceConstantAltitude_altitude_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1582,

    Group::ArrayOfIndex({384, }),

    Group::ArrayOfIndex({139, 147, altitude.isnull() ? Index(altitude_default.pos()) : Group::Index(altitude.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surfaceBlackbody(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1583,

    Group::ArrayOfIndex({313, 317, 312, }),

    Group::ArrayOfIndex({35, 104, 306, 262, 261, 321, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surfaceFastem(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric wind_speed,

               const Var::Vector transmittance,

               const Var::Numeric& salinity={},

               const Var::Numeric& wind_direction={},

               const Var::Index& fastem_version={}) {

  if (not salinity.isnull() and salinity.islast()) {

    throw std::runtime_error("salinity needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to surfaceFastem");

  } if (wind_speed.islast()) {

    throw std::runtime_error("wind_speed needs to be a defined WorkspaceNumeric since it is agenda input to surfaceFastem");

  } if (not wind_direction.isnull() and wind_direction.islast()) {

    throw std::runtime_error("wind_direction needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to surfaceFastem");

  } if (transmittance.islast()) {

    throw std::runtime_error("transmittance needs to be a defined WorkspaceVector since it is agenda input to surfaceFastem");

  } if (not fastem_version.isnull() and fastem_version.islast()) {

    throw std::runtime_error("fastem_version needs to be a defined WorkspaceIndex (or left default) since it is agenda input to surfaceFastem");

  }


  static const auto salinity_default = Var::NumericCreate(ws, 0.035,

    "surfaceFastem_salinity_autodefault",

    "auto generated variable with default from method definition");

  static const auto wind_direction_default = Var::NumericCreate(ws, 0,

    "surfaceFastem_wind_direction_autodefault",

    "auto generated variable with default from method definition");

  static const auto fastem_version_default = Var::IndexCreate(ws, 6,

    "surfaceFastem_fastem_version_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1584,

    Group::ArrayOfIndex({313, 317, 312, }),

    Group::ArrayOfIndex({35, 306, 104, 262, 261, 321, salinity.isnull() ? Index(salinity_default.pos()) : Group::Index(salinity.pos()), Group::Index(wind_speed.pos()), wind_direction.isnull() ? Index(wind_direction_default.pos()) : Group::Index(wind_direction.pos()), Group::Index(transmittance.pos()), fastem_version.isnull() ? Index(fastem_version_default.pos()) : Group::Index(fastem_version.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surfaceTessem(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric wind_speed,

               const Var::Numeric& salinity={}) {

  if (not salinity.isnull() and salinity.islast()) {

    throw std::runtime_error("salinity needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to surfaceTessem");

  } if (wind_speed.islast()) {

    throw std::runtime_error("wind_speed needs to be a defined WorkspaceNumeric since it is agenda input to surfaceTessem");

  }


  static const auto salinity_default = Var::NumericCreate(ws, 0.035,

    "surfaceTessem_salinity_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1585,

    Group::ArrayOfIndex({313, 317, 312, }),

    Group::ArrayOfIndex({35, 306, 104, 262, 261, 321, 329, 330, salinity.isnull() ? Index(salinity_default.pos()) : Group::Index(salinity.pos()), Group::Index(wind_speed.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surfaceTelsem(

    [[maybe_unused]] Workspace& ws,

               const Var::TelsemAtlas atlas,

               const Var::Numeric& r_min={},

               const Var::Numeric& r_max={},

               const Var::Numeric& d_max={}) {

  if (atlas.islast()) {

    throw std::runtime_error("atlas needs to be a defined WorkspaceTelsemAtlas since it is agenda input to surfaceTelsem");

  } if (not r_min.isnull() and r_min.islast()) {

    throw std::runtime_error("r_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to surfaceTelsem");

  } if (not r_max.isnull() and r_max.islast()) {

    throw std::runtime_error("r_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to surfaceTelsem");

  } if (not d_max.isnull() and d_max.islast()) {

    throw std::runtime_error("d_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to surfaceTelsem");

  }


  static const auto r_min_default = Var::NumericCreate(ws, 0,

    "surfaceTelsem_r_min_autodefault",

    "auto generated variable with default from method definition");

  static const auto r_max_default = Var::NumericCreate(ws, 1,

    "surfaceTelsem_r_max_autodefault",

    "auto generated variable with default from method definition");

  static const auto d_max_default = Var::NumericCreate(ws, -1.0,

    "surfaceTelsem_d_max_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1586,

    Group::ArrayOfIndex({313, 317, 312, }),

    Group::ArrayOfIndex({35, 306, 104, 139, 140, 148, 262, 261, 321, Group::Index(atlas.pos()), r_min.isnull() ? Index(r_min_default.pos()) : Group::Index(r_min.pos()), r_max.isnull() ? Index(r_max_default.pos()) : Group::Index(r_max.pos()), d_max.isnull() ? Index(d_max_default.pos()) : Group::Index(d_max.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surfaceFlatRefractiveIndex(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1587,

    Group::ArrayOfIndex({313, 317, 312, }),

    Group::ArrayOfIndex({104, 306, 35, 262, 261, 304, 321, 311, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surfaceFlatReflectivity(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1588,

    Group::ArrayOfIndex({313, 317, 312, }),

    Group::ArrayOfIndex({104, 306, 35, 262, 261, 304, 321, 322, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surfaceFlatRvRh(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1589,

    Group::ArrayOfIndex({313, 317, 312, }),

    Group::ArrayOfIndex({104, 306, 35, 262, 261, 304, 321, 323, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surfaceFlatScalarReflectivity(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1590,

    Group::ArrayOfIndex({313, 317, 312, }),

    Group::ArrayOfIndex({104, 306, 35, 262, 261, 304, 321, 324, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surfaceLambertianSimple(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& lambertian_nza={},

               const Var::Numeric& za_pos={}) {

  if (not lambertian_nza.isnull() and lambertian_nza.islast()) {

    throw std::runtime_error("lambertian_nza needs to be a defined WorkspaceIndex (or left default) since it is agenda input to surfaceLambertianSimple");

  } if (not za_pos.isnull() and za_pos.islast()) {

    throw std::runtime_error("za_pos needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to surfaceLambertianSimple");

  }


  static const auto lambertian_nza_default = Var::IndexCreate(ws, 9,

    "surfaceLambertianSimple_lambertian_nza_autodefault",

    "auto generated variable with default from method definition");

  static const auto za_pos_default = Var::NumericCreate(ws, 0.5,

    "surfaceLambertianSimple_za_pos_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1591,

    Group::ArrayOfIndex({313, 317, 312, }),

    Group::ArrayOfIndex({104, 306, 35, 262, 261, 314, 321, 324, lambertian_nza.isnull() ? Index(lambertian_nza_default.pos()) : Group::Index(lambertian_nza.pos()), za_pos.isnull() ? Index(za_pos_default.pos()) : Group::Index(za_pos.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surfaceSemiSpecularBy3beams(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric specular_factor,

               const Var::Numeric dza) {

  if (specular_factor.islast()) {

    throw std::runtime_error("specular_factor needs to be a defined WorkspaceNumeric since it is agenda input to surfaceSemiSpecularBy3beams");

  } if (dza.islast()) {

    throw std::runtime_error("dza needs to be a defined WorkspaceNumeric since it is agenda input to surfaceSemiSpecularBy3beams");

  }


  return MRecord(1592,

    Group::ArrayOfIndex({321, 313, 317, 312, }),

    Group::ArrayOfIndex({35, 104, 262, 261, 320, Group::Index(specular_factor.pos()), Group::Index(dza.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surfaceSplitSpecularTo3beams(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric specular_factor,

               const Var::Numeric dza) {

  if (specular_factor.islast()) {

    throw std::runtime_error("specular_factor needs to be a defined WorkspaceNumeric since it is agenda input to surfaceSplitSpecularTo3beams");

  } if (dza.islast()) {

    throw std::runtime_error("dza needs to be a defined WorkspaceNumeric since it is agenda input to surfaceSplitSpecularTo3beams");

  }


  return MRecord(1593,

    Group::ArrayOfIndex({313, 317, }),

    Group::ArrayOfIndex({35, 262, 261, Group::Index(specular_factor.pos()), Group::Index(dza.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surface_complex_refr_indexFromGriddedField5(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField5 complex_refr_index_field) {

  if (complex_refr_index_field.islast()) {

    throw std::runtime_error("complex_refr_index_field needs to be a defined WorkspaceGriddedField5 since it is agenda input to surface_complex_refr_indexFromGriddedField5");

  }


  return MRecord(1594,

    Group::ArrayOfIndex({311, }),

    Group::ArrayOfIndex({35, 139, 140, 148, 262, Group::Index(complex_refr_index_field.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surface_reflectivityFromGriddedField6(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField6 r_field) {

  if (r_field.islast()) {

    throw std::runtime_error("r_field needs to be a defined WorkspaceGriddedField6 since it is agenda input to surface_reflectivityFromGriddedField6");

  }


  return MRecord(1595,

    Group::ArrayOfIndex({322, }),

    Group::ArrayOfIndex({306, 104, 35, 139, 140, 148, 262, 261, Group::Index(r_field.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surface_rtpropCallAgendaX(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1596,

    Group::ArrayOfIndex({321, 313, 317, 312, }),

    Group::ArrayOfIndex({104, 262, 261, 319, 325, 326, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surface_scalar_reflectivityFromGriddedField4(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField4 r_field) {

  if (r_field.islast()) {

    throw std::runtime_error("r_field needs to be a defined WorkspaceGriddedField4 since it is agenda input to surface_scalar_reflectivityFromGriddedField4");

  }


  return MRecord(1597,

    Group::ArrayOfIndex({324, }),

    Group::ArrayOfIndex({306, 104, 35, 139, 140, 148, 262, 261, Group::Index(r_field.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surface_scalar_reflectivityFromSurface_rmatrix(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1598,

    Group::ArrayOfIndex({324, }),

    Group::ArrayOfIndex({317, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord surface_typeInterpTypeMask(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1599,

    Group::ArrayOfIndex({325, 326, }),

    Group::ArrayOfIndex({35, 139, 140, 148, 262, 327, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord SurfaceDummy(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1600,

    Group::ArrayOfIndex({93, 91, }),

    Group::ArrayOfIndex({35, 139, 147, 315, 316, 92, 136, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord SurfaceFastem(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector transmittance,

               const Var::Index& fastem_version={}) {

  if (transmittance.islast()) {

    throw std::runtime_error("transmittance needs to be a defined WorkspaceVector since it is agenda input to SurfaceFastem");

  } if (not fastem_version.isnull() and fastem_version.islast()) {

    throw std::runtime_error("fastem_version needs to be a defined WorkspaceIndex (or left default) since it is agenda input to SurfaceFastem");

  }


  static const auto fastem_version_default = Var::IndexCreate(ws, 6,

    "SurfaceFastem_fastem_version_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1601,

    Group::ArrayOfIndex({313, 317, 93, 312, 91, }),

    Group::ArrayOfIndex({306, 35, 139, 147, 104, 262, 261, 315, 316, 92, 136, Group::Index(transmittance.pos()), fastem_version.isnull() ? Index(fastem_version_default.pos()) : Group::Index(fastem_version.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord SurfaceTessem(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1602,

    Group::ArrayOfIndex({313, 317, 93, 312, 91, }),

    Group::ArrayOfIndex({306, 35, 139, 147, 104, 262, 261, 329, 330, 315, 316, 92, 136, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord TangentPointExtract(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector tan_pos) {

  if (tan_pos.islast()) {

    throw std::runtime_error("tan_pos needs to be a defined WorkspaceVector since it is output of TangentPointExtract");

  }


  return MRecord(1603,

    Group::ArrayOfIndex({Group::Index(tan_pos.pos()), }),

    Group::ArrayOfIndex({216, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord TangentPointPrint(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& level={}) {

  if (not level.isnull() and level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex (or left default) since it is agenda input to TangentPointPrint");

  }


  static const auto level_default = Var::IndexCreate(ws, 1,

    "TangentPointPrint_level_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1604,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({216, level.isnull() ? Index(level_default.pos()) : Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord telsemStandalone(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix emissivities,

               const Var::Numeric lat,

               const Var::Numeric lon,

               const Var::Numeric theta,

               const Var::Vector f,

               const Var::TelsemAtlas ta,

               const Var::Numeric& d_max={}) {

  if (emissivities.islast()) {

    throw std::runtime_error("emissivities needs to be a defined WorkspaceMatrix since it is output of telsemStandalone");

  } if (lat.islast()) {

    throw std::runtime_error("lat needs to be a defined WorkspaceNumeric since it is agenda input to telsemStandalone");

  } if (lon.islast()) {

    throw std::runtime_error("lon needs to be a defined WorkspaceNumeric since it is agenda input to telsemStandalone");

  } if (theta.islast()) {

    throw std::runtime_error("theta needs to be a defined WorkspaceNumeric since it is agenda input to telsemStandalone");

  } if (f.islast()) {

    throw std::runtime_error("f needs to be a defined WorkspaceVector since it is agenda input to telsemStandalone");

  } if (ta.islast()) {

    throw std::runtime_error("ta needs to be a defined WorkspaceTelsemAtlas since it is agenda input to telsemStandalone");

  } if (not d_max.isnull() and d_max.islast()) {

    throw std::runtime_error("d_max needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to telsemStandalone");

  }


  static const auto d_max_default = Var::NumericCreate(ws, -1,

    "telsemStandalone_d_max_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1605,

    Group::ArrayOfIndex({Group::Index(emissivities.pos()), }),

    Group::ArrayOfIndex({Group::Index(lat.pos()), Group::Index(lon.pos()), Group::Index(theta.pos()), Group::Index(f.pos()), Group::Index(ta.pos()), d_max.isnull() ? Index(d_max_default.pos()) : Group::Index(d_max.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord telsemAtlasLookup(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector emissivities,

               const Var::Numeric lat,

               const Var::Numeric lon,

               const Var::TelsemAtlas atlas) {

  if (emissivities.islast()) {

    throw std::runtime_error("emissivities needs to be a defined WorkspaceVector since it is output of telsemAtlasLookup");

  } if (lat.islast()) {

    throw std::runtime_error("lat needs to be a defined WorkspaceNumeric since it is agenda input to telsemAtlasLookup");

  } if (lon.islast()) {

    throw std::runtime_error("lon needs to be a defined WorkspaceNumeric since it is agenda input to telsemAtlasLookup");

  } if (atlas.islast()) {

    throw std::runtime_error("atlas needs to be a defined WorkspaceTelsemAtlas since it is agenda input to telsemAtlasLookup");

  }


  return MRecord(1606,

    Group::ArrayOfIndex({Group::Index(emissivities.pos()), }),

    Group::ArrayOfIndex({Group::Index(lat.pos()), Group::Index(lon.pos()), Group::Index(atlas.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord telsemSurfaceTypeLandSea(

    [[maybe_unused]] Workspace& ws,

               const Var::TelsemAtlas atlas) {

  if (atlas.islast()) {

    throw std::runtime_error("atlas needs to be a defined WorkspaceTelsemAtlas since it is agenda input to telsemSurfaceTypeLandSea");

  }


  return MRecord(1607,

    Group::ArrayOfIndex({325, }),

    Group::ArrayOfIndex({35, 139, 140, 148, 262, Group::Index(atlas.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord telsem_atlasReadAscii(

    [[maybe_unused]] Workspace& ws,

                     Var::TelsemAtlas atlas,

               const Var::String directory,

               const Var::Index month,

               const Var::String& filename_pattern={}) {

  if (atlas.islast()) {

    throw std::runtime_error("atlas needs to be a defined WorkspaceTelsemAtlas since it is output of telsem_atlasReadAscii");

  } if (directory.islast()) {

    throw std::runtime_error("directory needs to be a defined WorkspaceString since it is agenda input to telsem_atlasReadAscii");

  } if (month.islast()) {

    throw std::runtime_error("month needs to be a defined WorkspaceIndex since it is agenda input to telsem_atlasReadAscii");

  } if (not filename_pattern.isnull() and filename_pattern.islast()) {

    throw std::runtime_error("filename_pattern needs to be a defined WorkspaceString (or left default) since it is agenda input to telsem_atlasReadAscii");

  }


  static const auto filename_pattern_default = Var::StringCreate(ws, "ssmi_mean_emis_climato_@MM@_cov_interpol_M2",

    "telsem_atlasReadAscii_filename_pattern_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1608,

    Group::ArrayOfIndex({Group::Index(atlas.pos()), }),

    Group::ArrayOfIndex({Group::Index(directory.pos()), Group::Index(month.pos()), filename_pattern.isnull() ? Index(filename_pattern_default.pos()) : Group::Index(filename_pattern.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord telsem_atlasesReadAscii(

    [[maybe_unused]] Workspace& ws,

               const Var::String directory,

               const Var::String& filename_pattern={}) {

  if (directory.islast()) {

    throw std::runtime_error("directory needs to be a defined WorkspaceString since it is agenda input to telsem_atlasesReadAscii");

  } if (not filename_pattern.isnull() and filename_pattern.islast()) {

    throw std::runtime_error("filename_pattern needs to be a defined WorkspaceString (or left default) since it is agenda input to telsem_atlasesReadAscii");

  }


  static const auto filename_pattern_default = Var::StringCreate(ws, "ssmi_mean_emis_climato_@MM@_cov_interpol_M2",

    "telsem_atlasesReadAscii_filename_pattern_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1609,

    Group::ArrayOfIndex({328, }),

    Group::ArrayOfIndex({Group::Index(directory.pos()), filename_pattern.isnull() ? Index(filename_pattern_default.pos()) : Group::Index(filename_pattern.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Tensor3AddScalar(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 out,

               const Var::Tensor3 in,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Tensor3AddScalar");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is agenda input to Tensor3AddScalar");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to Tensor3AddScalar");

  }


  return MRecord(1610,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Tensor3ExtractFromTensor4(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 out,

               const Var::Tensor4 in,

               const Var::Index i,

               const Var::String direction) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Tensor3ExtractFromTensor4");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is agenda input to Tensor3ExtractFromTensor4");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceIndex since it is agenda input to Tensor3ExtractFromTensor4");

  } if (direction.islast()) {

    throw std::runtime_error("direction needs to be a defined WorkspaceString since it is agenda input to Tensor3ExtractFromTensor4");

  }


  return MRecord(1611,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(i.pos()), Group::Index(direction.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Tensor3Scale(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 out,

               const Var::Tensor3 in,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Tensor3Scale");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is agenda input to Tensor3Scale");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to Tensor3Scale");

  }


  return MRecord(1612,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Tensor3SetConstant(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 out,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor3 since it is output of Tensor3SetConstant");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to Tensor3SetConstant");

  }


  return MRecord(1613,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({186, 185, 184, Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Tensor4AddScalar(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 out,

               const Var::Tensor4 in,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of Tensor4AddScalar");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is agenda input to Tensor4AddScalar");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to Tensor4AddScalar");

  }


  return MRecord(1614,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Tensor4Scale(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 out,

               const Var::Tensor4 in,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of Tensor4Scale");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is agenda input to Tensor4Scale");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to Tensor4Scale");

  }


  return MRecord(1615,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Tensor4SetConstant(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 out,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor4 since it is output of Tensor4SetConstant");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to Tensor4SetConstant");

  }


  return MRecord(1616,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({187, 186, 185, 184, Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Tensor5Scale(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor5 out,

               const Var::Tensor5 in,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor5 since it is output of Tensor5Scale");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor5 since it is agenda input to Tensor5Scale");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to Tensor5Scale");

  }


  return MRecord(1617,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Tensor5SetConstant(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor5 out,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor5 since it is output of Tensor5SetConstant");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to Tensor5SetConstant");

  }


  return MRecord(1618,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({188, 187, 186, 185, 184, Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Tensor6Scale(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor6 out,

               const Var::Tensor6 in,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor6 since it is output of Tensor6Scale");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor6 since it is agenda input to Tensor6Scale");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to Tensor6Scale");

  }


  return MRecord(1619,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Tensor6SetConstant(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor6 out,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor6 since it is output of Tensor6SetConstant");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to Tensor6SetConstant");

  }


  return MRecord(1620,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({189, 188, 187, 186, 185, 184, Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Tensor7Scale(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor7 out,

               const Var::Tensor7 in,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor7 since it is output of Tensor7Scale");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor7 since it is agenda input to Tensor7Scale");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to Tensor7Scale");

  }


  return MRecord(1621,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Tensor7SetConstant(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor7 out,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceTensor7 since it is output of Tensor7SetConstant");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to Tensor7SetConstant");

  }


  return MRecord(1622,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({190, 189, 188, 187, 186, 185, 184, Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord TestArrayOfAgenda(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& index={}) {

  if (not index.isnull() and index.islast()) {

    throw std::runtime_error("index needs to be a defined WorkspaceIndex (or left default) since it is agenda input to TestArrayOfAgenda");

  }


  static const auto index_default = Var::IndexCreate(ws, 0,

    "TestArrayOfAgenda_index_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1623,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({332, index.isnull() ? Index(index_default.pos()) : Group::Index(index.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord TessemNNReadAscii(

    [[maybe_unused]] Workspace& ws,

                     Var::TessemNN tessem_nn,

               const Var::String filename) {

  if (tessem_nn.islast()) {

    throw std::runtime_error("tessem_nn needs to be a defined WorkspaceTessemNN since it is output of TessemNNReadAscii");

  } if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to TessemNNReadAscii");

  }


  return MRecord(1624,

    Group::ArrayOfIndex({Group::Index(tessem_nn.pos()), }),

    Group::ArrayOfIndex({Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord TestTessem(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector outvalues,

               const Var::TessemNN net,

               const Var::Vector invalues) {

  if (outvalues.islast()) {

    throw std::runtime_error("outvalues needs to be a defined WorkspaceVector since it is output of TestTessem");

  } if (net.islast()) {

    throw std::runtime_error("net needs to be a defined WorkspaceTessemNN since it is agenda input to TestTessem");

  } if (invalues.islast()) {

    throw std::runtime_error("invalues needs to be a defined WorkspaceVector since it is agenda input to TestTessem");

  }


  return MRecord(1625,

    Group::ArrayOfIndex({Group::Index(outvalues.pos()), }),

    Group::ArrayOfIndex({Group::Index(net.pos()), Group::Index(invalues.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Test(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1626,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord time_gridOffset(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric dt) {

  if (dt.islast()) {

    throw std::runtime_error("dt needs to be a defined WorkspaceNumeric since it is agenda input to time_gridOffset");

  }


  return MRecord(1627,

    Group::ArrayOfIndex({335, }),

    Group::ArrayOfIndex({Group::Index(dt.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord timerStart(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1628,

    Group::ArrayOfIndex({334, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord timerStop(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1629,

    Group::ArrayOfIndex({334, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord time_stampsSort(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTime out,

               const Var::ArrayOfTime in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfTime since it is output of time_stampsSort");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTime since it is agenda input to time_stampsSort");

  }


  return MRecord(1630,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({336, Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord time_stampsSort(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfVector out,

               const Var::ArrayOfVector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceArrayOfVector since it is output of time_stampsSort");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfVector since it is agenda input to time_stampsSort");

  }


  return MRecord(1631,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({336, Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord TMatrixTest(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1632,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::AbsorptionLines in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAbsorptionLines since it is output of Touch");

  }


  return MRecord(1633,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Agenda in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAgenda since it is output of Touch");

  }


  return MRecord(1634,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfAbsorptionLines in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAbsorptionLines since it is output of Touch");

  }


  return MRecord(1635,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfAbsorptionLines in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is output of Touch");

  }


  return MRecord(1636,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfAgenda in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAgenda since it is output of Touch");

  }


  return MRecord(1637,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField1 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is output of Touch");

  }


  return MRecord(1638,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField2 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is output of Touch");

  }


  return MRecord(1639,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfGriddedField3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is output of Touch");

  }


  return MRecord(1640,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfIndex in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfIndex since it is output of Touch");

  }


  return MRecord(1641,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is output of Touch");

  }


  return MRecord(1642,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfPpath in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPpath since it is output of Touch");

  }


  return MRecord(1643,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfPropagationMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is output of Touch");

  }


  return MRecord(1644,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfRadiationVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is output of Touch");

  }


  return MRecord(1645,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfScatteringMetaData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is output of Touch");

  }


  return MRecord(1646,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfSingleScatteringData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is output of Touch");

  }


  return MRecord(1647,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfSpeciesTag in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is output of Touch");

  }


  return MRecord(1648,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfStokesVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is output of Touch");

  }


  return MRecord(1649,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfString in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfString since it is output of Touch");

  }


  return MRecord(1650,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTensor3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is output of Touch");

  }


  return MRecord(1651,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTensor6 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is output of Touch");

  }


  return MRecord(1652,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTime in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTime since it is output of Touch");

  }


  return MRecord(1653,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfTransmissionMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is output of Touch");

  }


  return MRecord(1654,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfArrayOfVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfVector since it is output of Touch");

  }


  return MRecord(1655,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfCIARecord in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfCIARecord since it is output of Touch");

  }


  return MRecord(1656,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField1 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField1 since it is output of Touch");

  }


  return MRecord(1657,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField2 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField2 since it is output of Touch");

  }


  return MRecord(1658,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField3 since it is output of Touch");

  }


  return MRecord(1659,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfGriddedField4 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField4 since it is output of Touch");

  }


  return MRecord(1660,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfIndex in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfIndex since it is output of Touch");

  }


  return MRecord(1661,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfMatrix since it is output of Touch");

  }


  return MRecord(1662,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfPropagationMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPropagationMatrix since it is output of Touch");

  }


  return MRecord(1663,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfQuantumIdentifier in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is output of Touch");

  }


  return MRecord(1664,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfRadiationVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRadiationVector since it is output of Touch");

  }


  return MRecord(1665,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfRetrievalQuantity in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is output of Touch");

  }


  return MRecord(1666,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfScatteringMetaData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfScatteringMetaData since it is output of Touch");

  }


  return MRecord(1667,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSingleScatteringData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSingleScatteringData since it is output of Touch");

  }


  return MRecord(1668,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfSparse in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSparse since it is output of Touch");

  }


  return MRecord(1669,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfStokesVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfStokesVector since it is output of Touch");

  }


  return MRecord(1670,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfString in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfString since it is output of Touch");

  }


  return MRecord(1671,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTelsemAtlas in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTelsemAtlas since it is output of Touch");

  }


  return MRecord(1672,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor3 since it is output of Touch");

  }


  return MRecord(1673,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor4 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor4 since it is output of Touch");

  }


  return MRecord(1674,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor5 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor5 since it is output of Touch");

  }


  return MRecord(1675,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor6 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor6 since it is output of Touch");

  }


  return MRecord(1676,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTensor7 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor7 since it is output of Touch");

  }


  return MRecord(1677,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTime in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTime since it is output of Touch");

  }


  return MRecord(1678,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfTransmissionMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is output of Touch");

  }


  return MRecord(1679,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfVector since it is output of Touch");

  }


  return MRecord(1680,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ArrayOfXsecRecord in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfXsecRecord since it is output of Touch");

  }


  return MRecord(1681,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::CIARecord in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCIARecord since it is output of Touch");

  }


  return MRecord(1682,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::CovarianceMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCovarianceMatrix since it is output of Touch");

  }


  return MRecord(1683,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::EnergyLevelMap in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceEnergyLevelMap since it is output of Touch");

  }


  return MRecord(1684,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::GasAbsLookup in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGasAbsLookup since it is output of Touch");

  }


  return MRecord(1685,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::GridPos in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGridPos since it is output of Touch");

  }


  return MRecord(1686,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField1 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField1 since it is output of Touch");

  }


  return MRecord(1687,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField2 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField2 since it is output of Touch");

  }


  return MRecord(1688,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField3 since it is output of Touch");

  }


  return MRecord(1689,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField4 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField4 since it is output of Touch");

  }


  return MRecord(1690,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField5 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField5 since it is output of Touch");

  }


  return MRecord(1691,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::GriddedField6 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField6 since it is output of Touch");

  }


  return MRecord(1692,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::HitranRelaxationMatrixData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceHitranRelaxationMatrixData since it is output of Touch");

  }


  return MRecord(1693,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Index in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceIndex since it is output of Touch");

  }


  return MRecord(1694,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::MCAntenna in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMCAntenna since it is output of Touch");

  }


  return MRecord(1695,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Matrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is output of Touch");

  }


  return MRecord(1696,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Numeric in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceNumeric since it is output of Touch");

  }


  return MRecord(1697,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Ppath in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePpath since it is output of Touch");

  }


  return MRecord(1698,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::PropagationMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePropagationMatrix since it is output of Touch");

  }


  return MRecord(1699,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::QuantumIdentifier in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceQuantumIdentifier since it is output of Touch");

  }


  return MRecord(1700,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::RadiationVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRadiationVector since it is output of Touch");

  }


  return MRecord(1701,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Rational in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRational since it is output of Touch");

  }


  return MRecord(1702,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::ScatteringMetaData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceScatteringMetaData since it is output of Touch");

  }


  return MRecord(1703,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::SingleScatteringData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSingleScatteringData since it is output of Touch");

  }


  return MRecord(1704,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Sparse in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSparse since it is output of Touch");

  }


  return MRecord(1705,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::SpeciesAuxData in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSpeciesAuxData since it is output of Touch");

  }


  return MRecord(1706,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::StokesVector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceStokesVector since it is output of Touch");

  }


  return MRecord(1707,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::String in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceString since it is output of Touch");

  }


  return MRecord(1708,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::TelsemAtlas in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTelsemAtlas since it is output of Touch");

  }


  return MRecord(1709,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor3 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is output of Touch");

  }


  return MRecord(1710,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor4 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is output of Touch");

  }


  return MRecord(1711,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor5 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor5 since it is output of Touch");

  }


  return MRecord(1712,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor6 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor6 since it is output of Touch");

  }


  return MRecord(1713,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Tensor7 in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor7 since it is output of Touch");

  }


  return MRecord(1714,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Timer in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTimer since it is output of Touch");

  }


  return MRecord(1715,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Time in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTime since it is output of Touch");

  }


  return MRecord(1716,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::TessemNN in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTessemNN since it is output of Touch");

  }


  return MRecord(1717,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::TransmissionMatrix in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTransmissionMatrix since it is output of Touch");

  }


  return MRecord(1718,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is output of Touch");

  }


  return MRecord(1719,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Touch(

    [[maybe_unused]] Workspace& ws,

                     Var::Verbosity in) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVerbosity since it is output of Touch");

  }


  return MRecord(1720,

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord transmittanceFromIy_aux(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector transmittance) {

  if (transmittance.islast()) {

    throw std::runtime_error("transmittance needs to be a defined WorkspaceVector since it is output of transmittanceFromIy_aux");

  }


  return MRecord(1721,

    Group::ArrayOfIndex({Group::Index(transmittance.pos()), }),

    Group::ArrayOfIndex({122, 121, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorAddScalar(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Vector in,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorAddScalar");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to VectorAddScalar");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to VectorAddScalar");

  }


  return MRecord(1722,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorAddVector(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector c,

               const Var::Vector a,

               const Var::Vector b) {

  if (c.islast()) {

    throw std::runtime_error("c needs to be a defined WorkspaceVector since it is output of VectorAddVector");

  } if (a.islast()) {

    throw std::runtime_error("a needs to be a defined WorkspaceVector since it is agenda input to VectorAddVector");

  } if (b.islast()) {

    throw std::runtime_error("b needs to be a defined WorkspaceVector since it is agenda input to VectorAddVector");

  }


  return MRecord(1723,

    Group::ArrayOfIndex({Group::Index(c.pos()), }),

    Group::ArrayOfIndex({Group::Index(a.pos()), Group::Index(b.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorCrop(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Vector in,

               const Var::Numeric& min_value={},

               const Var::Numeric& max_value={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorCrop");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to VectorCrop");

  } if (not min_value.isnull() and min_value.islast()) {

    throw std::runtime_error("min_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to VectorCrop");

  } if (not max_value.isnull() and max_value.islast()) {

    throw std::runtime_error("max_value needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to VectorCrop");

  }


  static const auto min_value_default = Var::NumericCreate(ws, -99e99,

    "VectorCrop_min_value_autodefault",

    "auto generated variable with default from method definition");

  static const auto max_value_default = Var::NumericCreate(ws, 99e99,

    "VectorCrop_max_value_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1724,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), min_value.isnull() ? Index(min_value_default.pos()) : Group::Index(min_value.pos()), max_value.isnull() ? Index(max_value_default.pos()) : Group::Index(max_value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorExtractFromMatrix(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Matrix in,

               const Var::Index i,

               const Var::String direction) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorExtractFromMatrix");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is agenda input to VectorExtractFromMatrix");

  } if (i.islast()) {

    throw std::runtime_error("i needs to be a defined WorkspaceIndex since it is agenda input to VectorExtractFromMatrix");

  } if (direction.islast()) {

    throw std::runtime_error("direction needs to be a defined WorkspaceString since it is agenda input to VectorExtractFromMatrix");

  }


  return MRecord(1725,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(i.pos()), Group::Index(direction.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorFlip(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Vector in) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorFlip");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to VectorFlip");

  }


  return MRecord(1726,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorInsertGridPoints(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Vector in,

               const Var::Vector points) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorInsertGridPoints");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to VectorInsertGridPoints");

  } if (points.islast()) {

    throw std::runtime_error("points needs to be a defined WorkspaceVector since it is agenda input to VectorInsertGridPoints");

  }


  return MRecord(1727,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(points.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorLinSpace(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Numeric start,

               const Var::Numeric stop,

               const Var::Numeric step) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorLinSpace");

  } if (start.islast()) {

    throw std::runtime_error("start needs to be a defined WorkspaceNumeric since it is agenda input to VectorLinSpace");

  } if (stop.islast()) {

    throw std::runtime_error("stop needs to be a defined WorkspaceNumeric since it is agenda input to VectorLinSpace");

  } if (step.islast()) {

    throw std::runtime_error("step needs to be a defined WorkspaceNumeric since it is agenda input to VectorLinSpace");

  }


  return MRecord(1728,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(start.pos()), Group::Index(stop.pos()), Group::Index(step.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorLogSpace(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Numeric start,

               const Var::Numeric stop,

               const Var::Numeric step) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorLogSpace");

  } if (start.islast()) {

    throw std::runtime_error("start needs to be a defined WorkspaceNumeric since it is agenda input to VectorLogSpace");

  } if (stop.islast()) {

    throw std::runtime_error("stop needs to be a defined WorkspaceNumeric since it is agenda input to VectorLogSpace");

  } if (step.islast()) {

    throw std::runtime_error("step needs to be a defined WorkspaceNumeric since it is agenda input to VectorLogSpace");

  }


  return MRecord(1729,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(start.pos()), Group::Index(stop.pos()), Group::Index(step.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorMatrixMultiply(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Matrix m,

               const Var::Vector v) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorMatrixMultiply");

  } if (m.islast()) {

    throw std::runtime_error("m needs to be a defined WorkspaceMatrix since it is agenda input to VectorMatrixMultiply");

  } if (v.islast()) {

    throw std::runtime_error("v needs to be a defined WorkspaceVector since it is agenda input to VectorMatrixMultiply");

  }


  return MRecord(1730,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(m.pos()), Group::Index(v.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorNLinSpace(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Numeric start,

               const Var::Numeric stop) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorNLinSpace");

  } if (start.islast()) {

    throw std::runtime_error("start needs to be a defined WorkspaceNumeric since it is agenda input to VectorNLinSpace");

  } if (stop.islast()) {

    throw std::runtime_error("stop needs to be a defined WorkspaceNumeric since it is agenda input to VectorNLinSpace");

  }


  return MRecord(1731,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({183, Group::Index(start.pos()), Group::Index(stop.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorNLogSpace(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Numeric start,

               const Var::Numeric stop) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorNLogSpace");

  } if (start.islast()) {

    throw std::runtime_error("start needs to be a defined WorkspaceNumeric since it is agenda input to VectorNLogSpace");

  } if (stop.islast()) {

    throw std::runtime_error("stop needs to be a defined WorkspaceNumeric since it is agenda input to VectorNLogSpace");

  }


  return MRecord(1732,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({183, Group::Index(start.pos()), Group::Index(stop.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorReshapeMatrix(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Matrix in,

               const Var::String& direction={}) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorReshapeMatrix");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is agenda input to VectorReshapeMatrix");

  } if (not direction.isnull() and direction.islast()) {

    throw std::runtime_error("direction needs to be a defined WorkspaceString (or left default) since it is agenda input to VectorReshapeMatrix");

  }


  static const auto direction_default = Var::StringCreate(ws, "column",

    "VectorReshapeMatrix_direction_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1733,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), direction.isnull() ? Index(direction_default.pos()) : Group::Index(direction.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorScale(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Vector in,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorScale");

  } if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to VectorScale");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to VectorScale");

  }


  return MRecord(1734,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(in.pos()), Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorSetConstant(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Numeric value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorSetConstant");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceNumeric since it is agenda input to VectorSetConstant");

  }


  return MRecord(1735,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({183, Group::Index(value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorSet(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Vector value) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorSet");

  } if (value.islast()) {

    throw std::runtime_error("value needs to be a defined WorkspaceVector since it is agenda input to VectorSet");

  }


  return MRecord(1736,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(value.pos()), }),

    TokVal{value.value()}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorSubtractVector(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector c,

               const Var::Vector a,

               const Var::Vector b) {

  if (c.islast()) {

    throw std::runtime_error("c needs to be a defined WorkspaceVector since it is output of VectorSubtractVector");

  } if (a.islast()) {

    throw std::runtime_error("a needs to be a defined WorkspaceVector since it is agenda input to VectorSubtractVector");

  } if (b.islast()) {

    throw std::runtime_error("b needs to be a defined WorkspaceVector since it is agenda input to VectorSubtractVector");

  }


  return MRecord(1737,

    Group::ArrayOfIndex({Group::Index(c.pos()), }),

    Group::ArrayOfIndex({Group::Index(a.pos()), Group::Index(b.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorVectorMultiply(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector out,

               const Var::Vector v1,

               const Var::Vector v2) {

  if (out.islast()) {

    throw std::runtime_error("out needs to be a defined WorkspaceVector since it is output of VectorVectorMultiply");

  } if (v1.islast()) {

    throw std::runtime_error("v1 needs to be a defined WorkspaceVector since it is agenda input to VectorVectorMultiply");

  } if (v2.islast()) {

    throw std::runtime_error("v2 needs to be a defined WorkspaceVector since it is agenda input to VectorVectorMultiply");

  }


  return MRecord(1738,

    Group::ArrayOfIndex({Group::Index(out.pos()), }),

    Group::ArrayOfIndex({Group::Index(v1.pos()), Group::Index(v2.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorZtanToZaRefr1D(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector v_za,

               const Var::Vector v_ztan) {

  if (v_za.islast()) {

    throw std::runtime_error("v_za needs to be a defined WorkspaceVector since it is output of VectorZtanToZaRefr1D");

  } if (v_ztan.islast()) {

    throw std::runtime_error("v_ztan needs to be a defined WorkspaceVector since it is agenda input to VectorZtanToZaRefr1D");

  }


  return MRecord(1739,

    Group::ArrayOfIndex({Group::Index(v_za.pos()), }),

    Group::ArrayOfIndex({248, 286, 242, 338, 381, 344, 250, 35, 104, Group::Index(v_ztan.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord VectorZtanToZa1D(

    [[maybe_unused]] Workspace& ws,

                     Var::Vector v_za,

               const Var::Vector v_ztan) {

  if (v_za.islast()) {

    throw std::runtime_error("v_za needs to be a defined WorkspaceVector since it is output of VectorZtanToZa1D");

  } if (v_ztan.islast()) {

    throw std::runtime_error("v_ztan needs to be a defined WorkspaceVector since it is agenda input to VectorZtanToZa1D");

  }


  return MRecord(1740,

    Group::ArrayOfIndex({Group::Index(v_za.pos()), }),

    Group::ArrayOfIndex({286, 250, 35, Group::Index(v_ztan.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord verbosityInit(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1741,

    Group::ArrayOfIndex({343, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord verbositySet(

    [[maybe_unused]] Workspace& ws,

               const Var::Index agenda,

               const Var::Index screen,

               const Var::Index file) {

  if (agenda.islast()) {

    throw std::runtime_error("agenda needs to be a defined WorkspaceIndex since it is agenda input to verbositySet");

  } if (screen.islast()) {

    throw std::runtime_error("screen needs to be a defined WorkspaceIndex since it is agenda input to verbositySet");

  } if (file.islast()) {

    throw std::runtime_error("file needs to be a defined WorkspaceIndex since it is agenda input to verbositySet");

  }


  return MRecord(1742,

    Group::ArrayOfIndex({343, }),

    Group::ArrayOfIndex({Group::Index(agenda.pos()), Group::Index(screen.pos()), Group::Index(file.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord verbositySetAgenda(

    [[maybe_unused]] Workspace& ws,

               const Var::Index level) {

  if (level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex since it is agenda input to verbositySetAgenda");

  }


  return MRecord(1743,

    Group::ArrayOfIndex({343, }),

    Group::ArrayOfIndex({Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord verbositySetFile(

    [[maybe_unused]] Workspace& ws,

               const Var::Index level) {

  if (level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex since it is agenda input to verbositySetFile");

  }


  return MRecord(1744,

    Group::ArrayOfIndex({343, }),

    Group::ArrayOfIndex({Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord verbositySetScreen(

    [[maybe_unused]] Workspace& ws,

               const Var::Index level) {

  if (level.islast()) {

    throw std::runtime_error("level needs to be a defined WorkspaceIndex since it is agenda input to verbositySetScreen");

  }


  return MRecord(1745,

    Group::ArrayOfIndex({343, }),

    Group::ArrayOfIndex({Group::Index(level.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord vmr_fieldClip(

    [[maybe_unused]] Workspace& ws,

               const Var::String species,

               const Var::Numeric& limit_low={},

               const Var::Numeric& limit_high={}) {

  if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to vmr_fieldClip");

  } if (not limit_low.isnull() and limit_low.islast()) {

    throw std::runtime_error("limit_low needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to vmr_fieldClip");

  } if (not limit_high.isnull() and limit_high.islast()) {

    throw std::runtime_error("limit_high needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to vmr_fieldClip");

  }


  static const auto limit_low_default = Var::NumericCreate(ws, -std::numeric_limits<Numeric>::infinity(),

    "vmr_fieldClip_limit_low_autodefault",

    "auto generated variable with default from method definition");

  static const auto limit_high_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::infinity(),

    "vmr_fieldClip_limit_high_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1746,

    Group::ArrayOfIndex({344, }),

    Group::ArrayOfIndex({21, Group::Index(species.pos()), limit_low.isnull() ? Index(limit_low_default.pos()) : Group::Index(limit_low.pos()), limit_high.isnull() ? Index(limit_high_default.pos()) : Group::Index(limit_high.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord vmr_fieldPerturb(

    [[maybe_unused]] Workspace& ws,

               const Var::String species,

               const Var::Vector p_ret_grid,

               const Var::Vector lat_ret_grid,

               const Var::Vector lon_ret_grid,

               const Var::Index pert_index,

               const Var::Numeric pert_size,

               const Var::String& pert_mode={}) {

  if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to vmr_fieldPerturb");

  } if (p_ret_grid.islast()) {

    throw std::runtime_error("p_ret_grid needs to be a defined WorkspaceVector since it is agenda input to vmr_fieldPerturb");

  } if (lat_ret_grid.islast()) {

    throw std::runtime_error("lat_ret_grid needs to be a defined WorkspaceVector since it is agenda input to vmr_fieldPerturb");

  } if (lon_ret_grid.islast()) {

    throw std::runtime_error("lon_ret_grid needs to be a defined WorkspaceVector since it is agenda input to vmr_fieldPerturb");

  } if (pert_index.islast()) {

    throw std::runtime_error("pert_index needs to be a defined WorkspaceIndex since it is agenda input to vmr_fieldPerturb");

  } if (pert_size.islast()) {

    throw std::runtime_error("pert_size needs to be a defined WorkspaceNumeric since it is agenda input to vmr_fieldPerturb");

  } if (not pert_mode.isnull() and pert_mode.islast()) {

    throw std::runtime_error("pert_mode needs to be a defined WorkspaceString (or left default) since it is agenda input to vmr_fieldPerturb");

  }


  static const auto pert_mode_default = Var::StringCreate(ws, "absolute",

    "vmr_fieldPerturb_pert_mode_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1747,

    Group::ArrayOfIndex({344, }),

    Group::ArrayOfIndex({35, 242, 139, 147, 21, Group::Index(species.pos()), Group::Index(p_ret_grid.pos()), Group::Index(lat_ret_grid.pos()), Group::Index(lon_ret_grid.pos()), Group::Index(pert_index.pos()), Group::Index(pert_size.pos()), pert_mode.isnull() ? Index(pert_mode_default.pos()) : Group::Index(pert_mode.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord vmr_fieldPerturbAtmGrids(

    [[maybe_unused]] Workspace& ws,

               const Var::String species,

               const Var::Index pert_index,

               const Var::Numeric pert_size,

               const Var::String& pert_mode={}) {

  if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to vmr_fieldPerturbAtmGrids");

  } if (pert_index.islast()) {

    throw std::runtime_error("pert_index needs to be a defined WorkspaceIndex since it is agenda input to vmr_fieldPerturbAtmGrids");

  } if (pert_size.islast()) {

    throw std::runtime_error("pert_size needs to be a defined WorkspaceNumeric since it is agenda input to vmr_fieldPerturbAtmGrids");

  } if (not pert_mode.isnull() and pert_mode.islast()) {

    throw std::runtime_error("pert_mode needs to be a defined WorkspaceString (or left default) since it is agenda input to vmr_fieldPerturbAtmGrids");

  }


  static const auto pert_mode_default = Var::StringCreate(ws, "absolute",

    "vmr_fieldPerturbAtmGrids_pert_mode_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1748,

    Group::ArrayOfIndex({344, }),

    Group::ArrayOfIndex({35, 242, 139, 147, 21, Group::Index(species.pos()), Group::Index(pert_index.pos()), Group::Index(pert_size.pos()), pert_mode.isnull() ? Index(pert_mode_default.pos()) : Group::Index(pert_mode.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord vmr_fieldSetAllConstant(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector vmr_values) {

  if (vmr_values.islast()) {

    throw std::runtime_error("vmr_values needs to be a defined WorkspaceVector since it is agenda input to vmr_fieldSetAllConstant");

  }


  return MRecord(1749,

    Group::ArrayOfIndex({344, }),

    Group::ArrayOfIndex({21, Group::Index(vmr_values.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord water_p_eq_fieldMK05(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1750,

    Group::ArrayOfIndex({347, }),

    Group::ArrayOfIndex({338, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord vmr_fieldSetConstant(

    [[maybe_unused]] Workspace& ws,

               const Var::String species,

               const Var::Numeric vmr_value) {

  if (species.islast()) {

    throw std::runtime_error("species needs to be a defined WorkspaceString since it is agenda input to vmr_fieldSetConstant");

  } if (vmr_value.islast()) {

    throw std::runtime_error("vmr_value needs to be a defined WorkspaceNumeric since it is agenda input to vmr_fieldSetConstant");

  }


  return MRecord(1751,

    Group::ArrayOfIndex({344, }),

    Group::ArrayOfIndex({21, Group::Index(species.pos()), Group::Index(vmr_value.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Wigner6Init(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& fast_wigner_stored_symbols={},

               const Var::Index& largest_wigner_symbol_parameter={}) {

  if (not fast_wigner_stored_symbols.isnull() and fast_wigner_stored_symbols.islast()) {

    throw std::runtime_error("fast_wigner_stored_symbols needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Wigner6Init");

  } if (not largest_wigner_symbol_parameter.isnull() and largest_wigner_symbol_parameter.islast()) {

    throw std::runtime_error("largest_wigner_symbol_parameter needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Wigner6Init");

  }


  static const auto fast_wigner_stored_symbols_default = Var::IndexCreate(ws, 20000000,

    "Wigner6Init_fast_wigner_stored_symbols_autodefault",

    "auto generated variable with default from method definition");

  static const auto largest_wigner_symbol_parameter_default = Var::IndexCreate(ws, 250,

    "Wigner6Init_largest_wigner_symbol_parameter_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1752,

    Group::ArrayOfIndex({348, }),

    Group::ArrayOfIndex({fast_wigner_stored_symbols.isnull() ? Index(fast_wigner_stored_symbols_default.pos()) : Group::Index(fast_wigner_stored_symbols.pos()), largest_wigner_symbol_parameter.isnull() ? Index(largest_wigner_symbol_parameter_default.pos()) : Group::Index(largest_wigner_symbol_parameter.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Wigner3Init(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& fast_wigner_stored_symbols={},

               const Var::Index& largest_wigner_symbol_parameter={}) {

  if (not fast_wigner_stored_symbols.isnull() and fast_wigner_stored_symbols.islast()) {

    throw std::runtime_error("fast_wigner_stored_symbols needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Wigner3Init");

  } if (not largest_wigner_symbol_parameter.isnull() and largest_wigner_symbol_parameter.islast()) {

    throw std::runtime_error("largest_wigner_symbol_parameter needs to be a defined WorkspaceIndex (or left default) since it is agenda input to Wigner3Init");

  }


  static const auto fast_wigner_stored_symbols_default = Var::IndexCreate(ws, 20000000,

    "Wigner3Init_fast_wigner_stored_symbols_autodefault",

    "auto generated variable with default from method definition");

  static const auto largest_wigner_symbol_parameter_default = Var::IndexCreate(ws, 250,

    "Wigner3Init_largest_wigner_symbol_parameter_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1753,

    Group::ArrayOfIndex({348, }),

    Group::ArrayOfIndex({fast_wigner_stored_symbols.isnull() ? Index(fast_wigner_stored_symbols_default.pos()) : Group::Index(fast_wigner_stored_symbols.pos()), largest_wigner_symbol_parameter.isnull() ? Index(largest_wigner_symbol_parameter_default.pos()) : Group::Index(largest_wigner_symbol_parameter.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Wigner6Unload(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1754,

    Group::ArrayOfIndex({348, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord Wigner3Unload(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1755,

    Group::ArrayOfIndex({348, }),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WignerFastInfoPrint(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1756,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({348, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WindFieldsCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& interp_order={}) {

  if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WindFieldsCalc");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "WindFieldsCalc_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1757,

    Group::ArrayOfIndex({349, 351, 353, }),

    Group::ArrayOfIndex({242, 139, 147, 350, 352, 354, 35, interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WindFieldsCalcExpand1D(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& interp_order={}) {

  if (not interp_order.isnull() and interp_order.islast()) {

    throw std::runtime_error("interp_order needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WindFieldsCalcExpand1D");

  }


  static const auto interp_order_default = Var::IndexCreate(ws, 1,

    "WindFieldsCalcExpand1D_interp_order_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1758,

    Group::ArrayOfIndex({349, 351, 353, }),

    Group::ArrayOfIndex({242, 139, 147, 350, 352, 354, 35, interp_order.isnull() ? Index(interp_order_default.pos()) : Group::Index(interp_order.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WindRawRead(

    [[maybe_unused]] Workspace& ws,

               const Var::String basename) {

  if (basename.islast()) {

    throw std::runtime_error("basename needs to be a defined WorkspaceString since it is agenda input to WindRawRead");

  }


  return MRecord(1759,

    Group::ArrayOfIndex({350, 352, 354, }),

    Group::ArrayOfIndex({Group::Index(basename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord wind_u_fieldIncludePlanetRotation(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1760,

    Group::ArrayOfIndex({349, }),

    Group::ArrayOfIndex({35, 242, 139, 147, 250, 381, 206, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WMRFSelectChannels(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1761,

    Group::ArrayOfIndex({104, 356, 102, }),

    Group::ArrayOfIndex({355, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteMolTau(

    [[maybe_unused]] Workspace& ws,

               const Var::String filename) {

  if (filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString since it is agenda input to WriteMolTau");

  }


  return MRecord(1762,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({104, 381, 239, 35, Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDF(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to WriteNetCDF");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDF");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDF_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1763,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDF(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is agenda input to WriteNetCDF");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDF");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDF_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1764,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDF(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor3 in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is agenda input to WriteNetCDF");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDF");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDF_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1765,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDF(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is agenda input to WriteNetCDF");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDF");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDF_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1766,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDF(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor5 in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor5 since it is agenda input to WriteNetCDF");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDF");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDF_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1767,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDF(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfVector in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfVector since it is agenda input to WriteNetCDF");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDF");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDF_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1768,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDF(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfMatrix in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to WriteNetCDF");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDF");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDF_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1769,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDF(

    [[maybe_unused]] Workspace& ws,

               const Var::GasAbsLookup in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGasAbsLookup since it is agenda input to WriteNetCDF");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDF");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDF_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1770,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDFIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to WriteNetCDFIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDFIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDFIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1771,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDFIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is agenda input to WriteNetCDFIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDFIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDFIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1772,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDFIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor3 in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is agenda input to WriteNetCDFIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDFIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDFIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1773,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDFIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is agenda input to WriteNetCDFIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDFIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDFIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1774,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDFIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor5 in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor5 since it is agenda input to WriteNetCDFIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDFIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDFIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1775,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDFIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfVector in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfVector since it is agenda input to WriteNetCDFIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDFIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDFIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1776,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDFIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfMatrix in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to WriteNetCDFIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDFIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDFIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1777,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteNetCDFIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::GasAbsLookup in,

               const Var::String& filename={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGasAbsLookup since it is agenda input to WriteNetCDFIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteNetCDFIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteNetCDFIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1778,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::AbsorptionLines in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAbsorptionLines since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1779,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Agenda in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAgenda since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1780,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAbsorptionLines in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAbsorptionLines since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1781,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfAbsorptionLines in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1782,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAgenda in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAgenda since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1783,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField1 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1784,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField2 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1785,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField3 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1786,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfIndex in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfIndex since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1787,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfMatrix in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1788,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPpath in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPpath since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1789,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfPropagationMatrix in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1790,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfRadiationVector in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1791,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfScatteringMetaData in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1792,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfSingleScatteringData in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1793,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfSpeciesTag in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1794,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfStokesVector in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1795,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfString in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfString since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1796,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor3 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1797,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor6 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1798,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTime in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTime since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1799,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTransmissionMatrix in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1800,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfVector in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfVector since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1801,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfCIARecord in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfCIARecord since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1802,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField1 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField1 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1803,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField2 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField2 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1804,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField3 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1805,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField4 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField4 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1806,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfIndex in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfIndex since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1807,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfMatrix in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1808,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPropagationMatrix in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPropagationMatrix since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1809,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1810,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRadiationVector in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRadiationVector since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1811,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRetrievalQuantity in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1812,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfScatteringMetaData in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfScatteringMetaData since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1813,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfSingleScatteringData in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSingleScatteringData since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1814,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfSparse in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSparse since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1815,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfStokesVector in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfStokesVector since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1816,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfString in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfString since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1817,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTelsemAtlas in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTelsemAtlas since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1818,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor3 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor3 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1819,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor4 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor4 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1820,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor5 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor5 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1821,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor6 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor6 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1822,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor7 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor7 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1823,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTime in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTime since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1824,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTransmissionMatrix in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1825,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfVector in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfVector since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1826,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfXsecRecord in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfXsecRecord since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1827,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::CIARecord in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCIARecord since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1828,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::CovarianceMatrix in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCovarianceMatrix since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1829,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::EnergyLevelMap in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceEnergyLevelMap since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1830,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::GasAbsLookup in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGasAbsLookup since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1831,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::GridPos in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGridPos since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1832,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField1 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField1 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1833,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField2 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField2 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1834,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField3 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField3 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1835,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField4 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField4 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1836,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField5 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField5 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1837,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField6 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField6 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1838,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::HitranRelaxationMatrixData in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceHitranRelaxationMatrixData since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1839,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Index in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceIndex since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1840,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::MCAntenna in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMCAntenna since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1841,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1842,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceNumeric since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1843,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Ppath in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePpath since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1844,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::PropagationMatrix in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePropagationMatrix since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1845,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1846,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::RadiationVector in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRadiationVector since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1847,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Rational in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRational since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1848,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::ScatteringMetaData in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceScatteringMetaData since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1849,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::SingleScatteringData in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSingleScatteringData since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1850,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Sparse in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSparse since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1851,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::SpeciesAuxData in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSpeciesAuxData since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1852,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::StokesVector in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceStokesVector since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1853,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::String in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceString since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1854,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::TelsemAtlas in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTelsemAtlas since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1855,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor3 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1856,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1857,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor5 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor5 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1858,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor6 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor6 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1859,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor7 since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1860,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Timer in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTimer since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1861,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Time in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTime since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1862,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::TessemNN in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTessemNN since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1863,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::TransmissionMatrix in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTransmissionMatrix since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1864,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1865,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXML(

    [[maybe_unused]] Workspace& ws,

               const Var::Verbosity in,

               const Var::String& filename={},

               const Var::Index& no_clobber={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVerbosity since it is agenda input to WriteXML");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXML");

  } if (not no_clobber.isnull() and no_clobber.islast()) {

    throw std::runtime_error("no_clobber needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXML");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXML_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto no_clobber_default = Var::IndexCreate(ws, 0,

    "WriteXML_no_clobber_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1866,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), no_clobber.isnull() ? Index(no_clobber_default.pos()) : Group::Index(no_clobber.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::AbsorptionLines in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAbsorptionLines since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1867,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Agenda in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceAgenda since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1868,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAbsorptionLines in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAbsorptionLines since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1869,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfAbsorptionLines in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfAbsorptionLines since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1870,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfAgenda in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfAgenda since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1871,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField1 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField1 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1872,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField2 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField2 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1873,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfGriddedField3 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfGriddedField3 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1874,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfIndex in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfIndex since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1875,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfMatrix in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfMatrix since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1876,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPpath in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPpath since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1877,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfPropagationMatrix in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfPropagationMatrix since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1878,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfRadiationVector in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfRadiationVector since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1879,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfScatteringMetaData in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfScatteringMetaData since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1880,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfSingleScatteringData in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSingleScatteringData since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1881,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfSpeciesTag in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfSpeciesTag since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1882,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfStokesVector in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfStokesVector since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1883,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfString in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfString since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1884,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor3 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor3 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1885,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTensor6 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTensor6 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1886,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTime in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTime since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1887,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfTransmissionMatrix in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfTransmissionMatrix since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1888,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfArrayOfVector in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfArrayOfVector since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1889,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfCIARecord in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfCIARecord since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1890,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField1 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField1 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1891,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField2 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField2 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1892,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField3 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField3 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1893,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfGriddedField4 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfGriddedField4 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1894,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfIndex in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfIndex since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1895,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfMatrix in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfMatrix since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1896,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfPropagationMatrix in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfPropagationMatrix since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1897,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfQuantumIdentifier in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfQuantumIdentifier since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1898,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRadiationVector in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRadiationVector since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1899,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRetrievalQuantity in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1900,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfScatteringMetaData in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfScatteringMetaData since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1901,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfSingleScatteringData in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSingleScatteringData since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1902,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfSparse in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfSparse since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1903,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfStokesVector in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfStokesVector since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1904,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfString in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfString since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1905,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTelsemAtlas in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTelsemAtlas since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1906,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor3 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor3 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1907,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor4 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor4 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1908,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor5 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor5 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1909,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor6 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor6 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1910,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTensor7 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTensor7 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1911,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTime in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTime since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1912,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfTransmissionMatrix in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfTransmissionMatrix since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1913,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfVector in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfVector since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1914,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfXsecRecord in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceArrayOfXsecRecord since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1915,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::CIARecord in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCIARecord since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1916,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::CovarianceMatrix in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceCovarianceMatrix since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1917,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::EnergyLevelMap in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceEnergyLevelMap since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1918,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::GasAbsLookup in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGasAbsLookup since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1919,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::GridPos in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGridPos since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1920,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField1 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField1 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1921,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField2 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField2 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1922,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField3 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField3 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1923,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField4 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField4 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1924,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField5 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField5 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1925,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::GriddedField6 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceGriddedField6 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1926,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::HitranRelaxationMatrixData in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceHitranRelaxationMatrixData since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1927,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Index in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceIndex since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1928,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::MCAntenna in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMCAntenna since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1929,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Matrix in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceMatrix since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1930,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceNumeric since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1931,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Ppath in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePpath since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1932,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::PropagationMatrix in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspacePropagationMatrix since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1933,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::QuantumIdentifier in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceQuantumIdentifier since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1934,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::RadiationVector in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRadiationVector since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1935,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Rational in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceRational since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1936,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::ScatteringMetaData in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceScatteringMetaData since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1937,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::SingleScatteringData in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSingleScatteringData since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1938,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Sparse in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSparse since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1939,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::SpeciesAuxData in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceSpeciesAuxData since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1940,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::StokesVector in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceStokesVector since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1941,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::String in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceString since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1942,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::TelsemAtlas in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTelsemAtlas since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1943,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor3 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor3 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1944,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor4 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor4 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1945,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor5 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor5 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1946,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor6 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor6 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1947,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Tensor7 in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTensor7 since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1948,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Timer in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTimer since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1949,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Time in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTime since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1950,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::TessemNN in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTessemNN since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1951,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::TransmissionMatrix in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceTransmissionMatrix since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1952,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVector since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1953,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord WriteXMLIndexed(

    [[maybe_unused]] Workspace& ws,

               const Var::Verbosity in,

               const Var::String& filename={},

               const Var::Index& digits={}) {

  if (in.islast()) {

    throw std::runtime_error("in needs to be a defined WorkspaceVerbosity since it is agenda input to WriteXMLIndexed");

  } if (not filename.isnull() and filename.islast()) {

    throw std::runtime_error("filename needs to be a defined WorkspaceString (or left default) since it is agenda input to WriteXMLIndexed");

  } if (not digits.isnull() and digits.islast()) {

    throw std::runtime_error("digits needs to be a defined WorkspaceIndex (or left default) since it is agenda input to WriteXMLIndexed");

  }


  static const auto filename_default = Var::StringCreate(ws, "",

    "WriteXMLIndexed_filename_autodefault",

    "auto generated variable with default from method definition");

  static const auto digits_default = Var::IndexCreate(ws, 0,

    "WriteXMLIndexed_digits_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1954,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({196, 97, Group::Index(in.pos()), filename.isnull() ? Index(filename_default.pos()) : Group::Index(filename.pos()), digits.isnull() ? Index(digits_default.pos()) : Group::Index(digits.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord xaStandard(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1955,

    Group::ArrayOfIndex({359, }),

    Group::ArrayOfIndex({137, 36, 37, 35, 242, 139, 147, 338, 344, 21, 53, 48, 197, 198, 349, 351, 353, 149, 151, 153, 315, 316, 346, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord xClip(

    [[maybe_unused]] Workspace& ws,

               const Var::Index ijq,

               const Var::Numeric& limit_low={},

               const Var::Numeric& limit_high={}) {

  if (ijq.islast()) {

    throw std::runtime_error("ijq needs to be a defined WorkspaceIndex since it is agenda input to xClip");

  } if (not limit_low.isnull() and limit_low.islast()) {

    throw std::runtime_error("limit_low needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to xClip");

  } if (not limit_high.isnull() and limit_high.islast()) {

    throw std::runtime_error("limit_high needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to xClip");

  }


  static const auto limit_low_default = Var::NumericCreate(ws, -std::numeric_limits<Numeric>::infinity(),

    "xClip_limit_low_autodefault",

    "auto generated variable with default from method definition");

  static const auto limit_high_default = Var::NumericCreate(ws, std::numeric_limits<Numeric>::infinity(),

    "xClip_limit_high_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1956,

    Group::ArrayOfIndex({358, }),

    Group::ArrayOfIndex({137, Group::Index(ijq.pos()), limit_low.isnull() ? Index(limit_low_default.pos()) : Group::Index(limit_low.pos()), limit_high.isnull() ? Index(limit_high_default.pos()) : Group::Index(limit_high.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord x2artsAtmAndSurf(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1957,

    Group::ArrayOfIndex({344, 338, 197, 349, 351, 353, 149, 151, 153, 315, }),

    Group::ArrayOfIndex({137, 358, 36, 37, 35, 242, 139, 147, 21, 53, 48, 198, 316, 346, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord x2artsSensor(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1958,

    Group::ArrayOfIndex({283, 102, 362, 287, 292, 294, 290, 293, 295, 291, 156, }),

    Group::ArrayOfIndex({137, 358, 289, 281, 296, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord x2artsSpectroscopy(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1959,

    Group::ArrayOfIndex({}),

    Group::ArrayOfIndex({}),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord yApplySensorPol(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1960,

    Group::ArrayOfIndex({360, 363, 366, 367, 365, 361, 364, 134, }),

    Group::ArrayOfIndex({306, 136, 286, 285, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord yApplyUnit(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1961,

    Group::ArrayOfIndex({360, 134, }),

    Group::ArrayOfIndex({363, 366, 133, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ybatchCalc(

    [[maybe_unused]] Workspace& ws,

               const Var::Index& robust={}) {

  if (not robust.isnull() and robust.islast()) {

    throw std::runtime_error("robust needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ybatchCalc");

  }


  static const auto robust_default = Var::IndexCreate(ws, 0,

    "ybatchCalc_robust_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1962,

    Group::ArrayOfIndex({369, 370, 374, }),

    Group::ArrayOfIndex({376, 375, 371, robust.isnull() ? Index(robust_default.pos()) : Group::Index(robust.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord yColdAtmHot(

    [[maybe_unused]] Workspace& ws,

               const Var::Vector cold,

               const Var::Vector atm,

               const Var::Vector hot,

               const Var::Numeric cold_temp,

               const Var::Numeric hot_temp,

               const Var::Index& calib={}) {

  if (cold.islast()) {

    throw std::runtime_error("cold needs to be a defined WorkspaceVector since it is agenda input to yColdAtmHot");

  } if (atm.islast()) {

    throw std::runtime_error("atm needs to be a defined WorkspaceVector since it is agenda input to yColdAtmHot");

  } if (hot.islast()) {

    throw std::runtime_error("hot needs to be a defined WorkspaceVector since it is agenda input to yColdAtmHot");

  } if (cold_temp.islast()) {

    throw std::runtime_error("cold_temp needs to be a defined WorkspaceNumeric since it is agenda input to yColdAtmHot");

  } if (hot_temp.islast()) {

    throw std::runtime_error("hot_temp needs to be a defined WorkspaceNumeric since it is agenda input to yColdAtmHot");

  } if (not calib.isnull() and calib.islast()) {

    throw std::runtime_error("calib needs to be a defined WorkspaceIndex (or left default) since it is agenda input to yColdAtmHot");

  }


  static const auto calib_default = Var::IndexCreate(ws, 1,

    "yColdAtmHot_calib_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1963,

    Group::ArrayOfIndex({360, }),

    Group::ArrayOfIndex({Group::Index(cold.pos()), Group::Index(atm.pos()), Group::Index(hot.pos()), Group::Index(cold_temp.pos()), Group::Index(hot_temp.pos()), calib.isnull() ? Index(calib_default.pos()) : Group::Index(calib.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ybatchMetProfiles(

    [[maybe_unused]] Workspace& ws,

               const Var::Index nelem_p_grid,

               const Var::String met_profile_path,

               const Var::String met_profile_pnd_path) {

  if (nelem_p_grid.islast()) {

    throw std::runtime_error("nelem_p_grid needs to be a defined WorkspaceIndex since it is agenda input to ybatchMetProfiles");

  } if (met_profile_path.islast()) {

    throw std::runtime_error("met_profile_path needs to be a defined WorkspaceString since it is agenda input to ybatchMetProfiles");

  } if (met_profile_pnd_path.islast()) {

    throw std::runtime_error("met_profile_pnd_path needs to be a defined WorkspaceString since it is agenda input to ybatchMetProfiles");

  }


  return MRecord(1964,

    Group::ArrayOfIndex({369, }),

    Group::ArrayOfIndex({21, 176, 104, 172, 286, 250, 139, 147, 35, 267, Group::Index(nelem_p_grid.pos()), Group::Index(met_profile_path.pos()), Group::Index(met_profile_pnd_path.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ybatchMetProfilesClear(

    [[maybe_unused]] Workspace& ws,

               const Var::Index nelem_p_grid,

               const Var::String met_profile_path) {

  if (nelem_p_grid.islast()) {

    throw std::runtime_error("nelem_p_grid needs to be a defined WorkspaceIndex since it is agenda input to ybatchMetProfilesClear");

  } if (met_profile_path.islast()) {

    throw std::runtime_error("met_profile_path needs to be a defined WorkspaceString since it is agenda input to ybatchMetProfilesClear");

  }


  return MRecord(1965,

    Group::ArrayOfIndex({369, }),

    Group::ArrayOfIndex({21, 176, 104, 172, 286, 250, Group::Index(nelem_p_grid.pos()), Group::Index(met_profile_path.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ybatchTimeAveraging(

    [[maybe_unused]] Workspace& ws,

               const Var::String time_step,

               const Var::Index& disregard_first={},

               const Var::Index& disregard_last={}) {

  if (time_step.islast()) {

    throw std::runtime_error("time_step needs to be a defined WorkspaceString since it is agenda input to ybatchTimeAveraging");

  } if (not disregard_first.isnull() and disregard_first.islast()) {

    throw std::runtime_error("disregard_first needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ybatchTimeAveraging");

  } if (not disregard_last.isnull() and disregard_last.islast()) {

    throw std::runtime_error("disregard_last needs to be a defined WorkspaceIndex (or left default) since it is agenda input to ybatchTimeAveraging");

  }


  static const auto disregard_first_default = Var::IndexCreate(ws, 0,

    "ybatchTimeAveraging_disregard_first_autodefault",

    "auto generated variable with default from method definition");

  static const auto disregard_last_default = Var::IndexCreate(ws, 0,

    "ybatchTimeAveraging_disregard_last_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1966,

    Group::ArrayOfIndex({369, 335, 59, 55, }),

    Group::ArrayOfIndex({Group::Index(time_step.pos()), disregard_first.isnull() ? Index(disregard_first_default.pos()) : Group::Index(disregard_first.pos()), disregard_last.isnull() ? Index(disregard_last_default.pos()) : Group::Index(disregard_last.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ybatchTroposphericCorrectionNaiveMedianForward(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfIndex range,

               const Var::Vector trop_temp,

               const Var::Numeric& targ_temp={}) {

  if (range.islast()) {

    throw std::runtime_error("range needs to be a defined WorkspaceArrayOfIndex since it is agenda input to ybatchTroposphericCorrectionNaiveMedianForward");

  } if (trop_temp.islast()) {

    throw std::runtime_error("trop_temp needs to be a defined WorkspaceVector since it is agenda input to ybatchTroposphericCorrectionNaiveMedianForward");

  } if (not targ_temp.isnull() and targ_temp.islast()) {

    throw std::runtime_error("targ_temp needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to ybatchTroposphericCorrectionNaiveMedianForward");

  }


  static const auto targ_temp_default = Var::NumericCreate(ws, 2.73,

    "ybatchTroposphericCorrectionNaiveMedianForward_targ_temp_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1967,

    Group::ArrayOfIndex({373, 369, }),

    Group::ArrayOfIndex({Group::Index(range.pos()), Group::Index(trop_temp.pos()), targ_temp.isnull() ? Index(targ_temp_default.pos()) : Group::Index(targ_temp.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ybatchTroposphericCorrectionNaiveMedianInverse(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1968,

    Group::ArrayOfIndex({369, }),

    Group::ArrayOfIndex({373, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord yCalc(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1969,

    Group::ArrayOfIndex({360, 363, 366, 367, 365, 361, 364, 134, }),

    Group::ArrayOfIndex({37, 36, 35, 339, 53, 48, 268, 281, 306, 104, 286, 283, 337, 156, 287, 292, 294, 290, 133, 127, 109, 135, 136, 137, 122, }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord yCalcAppend(

    [[maybe_unused]] Workspace& ws,

               const Var::ArrayOfRetrievalQuantity jacobian_quantities_copy,

               const Var::Index& append_instrument_wfs={}) {

  if (jacobian_quantities_copy.islast()) {

    throw std::runtime_error("jacobian_quantities_copy needs to be a defined WorkspaceArrayOfRetrievalQuantity since it is agenda input to yCalcAppend");

  } if (not append_instrument_wfs.isnull() and append_instrument_wfs.islast()) {

    throw std::runtime_error("append_instrument_wfs needs to be a defined WorkspaceIndex (or left default) since it is agenda input to yCalcAppend");

  }


  static const auto append_instrument_wfs_default = Var::IndexCreate(ws, 0,

    "yCalcAppend_append_instrument_wfs_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1970,

    Group::ArrayOfIndex({360, 363, 366, 367, 365, 361, 364, 134, 137, }),

    Group::ArrayOfIndex({37, 36, 35, 339, 53, 48, 268, 281, 306, 104, 286, 283, 337, 156, 287, 292, 294, 290, 133, 127, 109, 135, 136, 122, Group::Index(jacobian_quantities_copy.pos()), append_instrument_wfs.isnull() ? Index(append_instrument_wfs_default.pos()) : Group::Index(append_instrument_wfs.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord yActive(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric& ze_tref={},

               const Var::Numeric& k2={},

               const Var::Numeric& dbze_min={}) {

  if (not ze_tref.isnull() and ze_tref.islast()) {

    throw std::runtime_error("ze_tref needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to yActive");

  } if (not k2.isnull() and k2.islast()) {

    throw std::runtime_error("k2 needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to yActive");

  } if (not dbze_min.isnull() and dbze_min.islast()) {

    throw std::runtime_error("dbze_min needs to be a defined WorkspaceNumeric (or left default) since it is agenda input to yActive");

  }


  static const auto ze_tref_default = Var::NumericCreate(ws, 273.15,

    "yActive_ze_tref_autodefault",

    "auto generated variable with default from method definition");

  static const auto k2_default = Var::NumericCreate(ws, -1,

    "yActive_k2_autodefault",

    "auto generated variable with default from method definition");

  static const auto dbze_min_default = Var::NumericCreate(ws, -99,

    "yActive_dbze_min_autodefault",

    "auto generated variable with default from method definition");

  return MRecord(1971,

    Group::ArrayOfIndex({360, 363, 366, 367, 365, 361, 364, 134, }),

    Group::ArrayOfIndex({37, 36, 133, 122, 306, 104, 35, 339, 53, 48, 286, 283, 281, 136, 137, 127, 109, 113, 246, ze_tref.isnull() ? Index(ze_tref_default.pos()) : Group::Index(ze_tref.pos()), k2.isnull() ? Index(k2_default.pos()) : Group::Index(k2.pos()), dbze_min.isnull() ? Index(dbze_min_default.pos()) : Group::Index(dbze_min.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord ySimpleSpectrometer(

    [[maybe_unused]] Workspace& ws,

               const Var::Numeric df) {

  if (df.islast()) {

    throw std::runtime_error("df needs to be a defined WorkspaceNumeric since it is agenda input to ySimpleSpectrometer");

  }


  return MRecord(1972,

    Group::ArrayOfIndex({360, 363, }),

    Group::ArrayOfIndex({118, 306, 104, Group::Index(df.pos()), }),

    TokVal{}, Agenda{});

}


[[nodiscard]] inline

MRecord z_fieldFromHSE(

    [[maybe_unused]] Workspace& ws) {

  return MRecord(1973,

    Group::ArrayOfIndex({381, }),

    Group::ArrayOfIndex({35, 242, 139, 147, 140, 148, 21, 338, 344, 250, 384, 36, 108, 178, 244, 383, }),

    TokVal{}, Agenda{});

}


}  // ARTS::AgendaMethod


namespace ARTS::AgendaExecute {


inline void abs_xsec_agenda(Workspace& ws) {

  abs_xsec_agendaExecute(ws,

             Var::abs_xsec_per_species(ws).value(),

             Var::src_xsec_per_species(ws).value(),

             Var::dabs_xsec_per_species_dx(ws).value(),

             Var::dsrc_xsec_per_species_dx(ws).value(),

             Var::abs_species(ws).value(),

             Var::jacobian_quantities(ws).value(),

             Var::abs_species_active(ws).value(),

             Var::f_grid(ws).value(),

             Var::abs_p(ws).value(),

             Var::abs_t(ws).value(),

             Var::abs_nlte(ws).value(),

             Var::abs_vmrs(ws).value(),

             Var::abs_xsec_agenda(ws).value());

}


inline void dobatch_calc_agenda(Workspace& ws) {

  dobatch_calc_agendaExecute(ws,

             Var::spectral_radiance_field(ws).value(),

             Var::radiance_field(ws).value(),

             Var::irradiance_field(ws).value(),

             Var::spectral_irradiance_field(ws).value(),

             Var::ybatch_index(ws).value(),

             Var::dobatch_calc_agenda(ws).value());

}


inline void doit_conv_test_agenda(Workspace& ws) {

  doit_conv_test_agendaExecute(ws,

             Var::doit_conv_flag(ws).value(),

             Var::doit_iteration_counter(ws).value(),

             Var::cloudbox_field_mono(ws).value(),

             Var::cloudbox_field_mono_old(ws).value(),

             Var::doit_conv_test_agenda(ws).value());

}


inline void doit_mono_agenda(Workspace& ws) {

  doit_mono_agendaExecute(ws,

             Var::cloudbox_field_mono(ws).value(),

             Var::f_grid(ws).value(),

             Var::f_index(ws).value(),

             Var::doit_mono_agenda(ws).value());

}


inline void doit_rte_agenda(Workspace& ws) {

  doit_rte_agendaExecute(ws,

             Var::cloudbox_field_mono(ws).value(),

             Var::doit_scat_field(ws).value(),

             Var::doit_rte_agenda(ws).value());

}


inline void doit_scat_field_agenda(Workspace& ws) {

  doit_scat_field_agendaExecute(ws,

             Var::doit_scat_field(ws).value(),

             Var::cloudbox_field_mono(ws).value(),

             Var::doit_scat_field_agenda(ws).value());

}


inline void forloop_agenda(Workspace& ws) {

  forloop_agendaExecute(ws,

             Var::forloop_index(ws).value(),

             Var::forloop_agenda(ws).value());

}


inline void g0_agenda(Workspace& ws) {

  g0_agendaExecute(ws,

             Var::g0(ws).value(),

             Var::lat(ws).value(),

             Var::lon(ws).value(),

             Var::g0_agenda(ws).value());

}


inline void geo_pos_agenda(Workspace& ws) {

  geo_pos_agendaExecute(ws,

             Var::geo_pos(ws).value(),

             Var::ppath(ws).value(),

             Var::geo_pos_agenda(ws).value());

}


inline void inversion_iterate_agenda(Workspace& ws) {

  inversion_iterate_agendaExecute(ws,

             Var::yf(ws).value(),

             Var::jacobian(ws).value(),

             Var::x(ws).value(),

             Var::jacobian_do(ws).value(),

             Var::inversion_iteration_counter(ws).value(),

             Var::inversion_iterate_agenda(ws).value());

}


inline void iy_cloudbox_agenda(Workspace& ws) {

  iy_cloudbox_agendaExecute(ws,

             Var::iy(ws).value(),

             Var::f_grid(ws).value(),

             Var::rtp_pos(ws).value(),

             Var::rtp_los(ws).value(),

             Var::iy_cloudbox_agenda(ws).value());

}


inline void iy_independent_beam_approx_agenda(Workspace& ws) {

  iy_independent_beam_approx_agendaExecute(ws,

             Var::iy(ws).value(),

             Var::iy_aux(ws).value(),

             Var::ppath(ws).value(),

             Var::diy_dx(ws).value(),

             Var::iy_agenda_call1(ws).value(),

             Var::iy_unit(ws).value(),

             Var::iy_transmission(ws).value(),

             Var::iy_aux_vars(ws).value(),

             Var::iy_id(ws).value(),

             Var::atmosphere_dim(ws).value(),

             Var::p_grid(ws).value(),

             Var::lat_grid(ws).value(),

             Var::lon_grid(ws).value(),

             Var::lat_true(ws).value(),

             Var::lon_true(ws).value(),

             Var::t_field(ws).value(),

             Var::z_field(ws).value(),

             Var::vmr_field(ws).value(),

             Var::z_surface(ws).value(),

             Var::ppath_lmax(ws).value(),

             Var::ppath_lraytrace(ws).value(),

             Var::cloudbox_on(ws).value(),

             Var::cloudbox_limits(ws).value(),

             Var::pnd_field(ws).value(),

             Var::jacobian_do(ws).value(),

             Var::f_grid(ws).value(),

             Var::rte_pos(ws).value(),

             Var::rte_los(ws).value(),

             Var::rte_pos2(ws).value(),

             Var::iy_independent_beam_approx_agenda(ws).value());

}


inline void iy_loop_freqs_agenda(Workspace& ws) {

  iy_loop_freqs_agendaExecute(ws,

             Var::iy(ws).value(),

             Var::iy_aux(ws).value(),

             Var::ppath(ws).value(),

             Var::diy_dx(ws).value(),

             Var::iy_agenda_call1(ws).value(),

             Var::iy_transmission(ws).value(),

             Var::iy_aux_vars(ws).value(),

             Var::iy_id(ws).value(),

             Var::f_grid(ws).value(),

             Var::rte_pos(ws).value(),

             Var::rte_los(ws).value(),

             Var::rte_pos2(ws).value(),

             Var::iy_loop_freqs_agenda(ws).value());

}


inline void iy_main_agenda(Workspace& ws) {

  iy_main_agendaExecute(ws,

             Var::iy(ws).value(),

             Var::iy_aux(ws).value(),

             Var::ppath(ws).value(),

             Var::diy_dx(ws).value(),

             Var::iy_agenda_call1(ws).value(),

             Var::iy_transmission(ws).value(),

             Var::iy_aux_vars(ws).value(),

             Var::iy_id(ws).value(),

             Var::iy_unit(ws).value(),

             Var::cloudbox_on(ws).value(),

             Var::jacobian_do(ws).value(),

             Var::f_grid(ws).value(),

             Var::nlte_field(ws).value(),

             Var::rte_pos(ws).value(),

             Var::rte_los(ws).value(),

             Var::rte_pos2(ws).value(),

             Var::iy_main_agenda(ws).value());

}


inline void iy_space_agenda(Workspace& ws) {

  iy_space_agendaExecute(ws,

             Var::iy(ws).value(),

             Var::f_grid(ws).value(),

             Var::rtp_pos(ws).value(),

             Var::rtp_los(ws).value(),

             Var::iy_space_agenda(ws).value());

}


inline void iy_surface_agenda(Workspace& ws) {

  iy_surface_agendaExecute(ws,

             Var::iy(ws).value(),

             Var::diy_dx(ws).value(),

             Var::dsurface_rmatrix_dx(ws).value(),

             Var::dsurface_emission_dx(ws).value(),

             Var::iy_unit(ws).value(),

             Var::iy_transmission(ws).value(),

             Var::iy_id(ws).value(),

             Var::cloudbox_on(ws).value(),

             Var::jacobian_do(ws).value(),

             Var::iy_main_agenda(ws).value(),

             Var::f_grid(ws).value(),

             Var::nlte_field(ws).value(),

             Var::rtp_pos(ws).value(),

             Var::rtp_los(ws).value(),

             Var::rte_pos2(ws).value(),

             Var::surface_props_data(ws).value(),

             Var::dsurface_names(ws).value(),

             Var::iy_surface_agenda(ws).value());

}


inline void iy_surface_agenda_array(Workspace& ws) {

  iy_surface_agenda_arrayExecute(ws,

             Var::iy(ws).value(),

             Var::diy_dx(ws).value(),

             Var::agenda_array_index(ws).value(),

             Var::iy_unit(ws).value(),

             Var::iy_transmission(ws).value(),

             Var::iy_id(ws).value(),

             Var::cloudbox_on(ws).value(),

             Var::jacobian_do(ws).value(),

             Var::iy_main_agenda(ws).value(),

             Var::f_grid(ws).value(),

             Var::rtp_pos(ws).value(),

             Var::rtp_los(ws).value(),

             Var::rte_pos2(ws).value(),

             Var::surface_type_aux(ws).value(),

             Var::iy_surface_agenda_array(ws).value());

}


inline void iy_transmitter_agenda(Workspace& ws) {

  iy_transmitter_agendaExecute(ws,

             Var::iy(ws).value(),

             Var::f_grid(ws).value(),

             Var::rtp_pos(ws).value(),

             Var::rtp_los(ws).value(),

             Var::iy_transmitter_agenda(ws).value());

}


inline void jacobian_agenda(Workspace& ws) {

  jacobian_agendaExecute(ws,

             Var::jacobian(ws).value(),

             Var::mblock_index(ws).value(),

             Var::iyb(ws).value(),

             Var::yb(ws).value(),

             Var::jacobian_agenda(ws).value());

}


inline void main_agenda(Workspace& ws) {

  main_agendaExecute(ws,

             Var::main_agenda(ws).value());

}


inline void met_profile_calc_agenda(Workspace& ws) {

  met_profile_calc_agendaExecute(ws,

             Var::y(ws).value(),

             Var::t_field_raw(ws).value(),

             Var::vmr_field_raw(ws).value(),

             Var::z_field_raw(ws).value(),

             Var::pnd_field_raw(ws).value(),

             Var::p_grid(ws).value(),

             Var::sensor_los(ws).value(),

             Var::cloudbox_on(ws).value(),

             Var::cloudbox_limits(ws).value(),

             Var::z_surface(ws).value(),

             Var::met_profile_calc_agenda(ws).value());

}


inline void pha_mat_spt_agenda(Workspace& ws) {

  pha_mat_spt_agendaExecute(ws,

             Var::pha_mat_spt(ws).value(),

             Var::za_index(ws).value(),

             Var::scat_lat_index(ws).value(),

             Var::scat_lon_index(ws).value(),

             Var::scat_p_index(ws).value(),

             Var::aa_index(ws).value(),

             Var::rtp_temperature(ws).value(),

             Var::pha_mat_spt_agenda(ws).value());

}


inline void pnd_agenda_array(Workspace& ws) {

  pnd_agenda_arrayExecute(ws,

             Var::pnd_data(ws).value(),

             Var::dpnd_data_dx(ws).value(),

             Var::agenda_array_index(ws).value(),

             Var::pnd_agenda_input_t(ws).value(),

             Var::pnd_agenda_input(ws).value(),

             Var::pnd_agenda_input_names(ws).value(),

             Var::dpnd_data_dx_names(ws).value(),

             Var::pnd_agenda_array(ws).value());

}


inline void ppath_agenda(Workspace& ws) {

  ppath_agendaExecute(ws,

             Var::ppath(ws).value(),

             Var::ppath_lmax(ws).value(),

             Var::ppath_lraytrace(ws).value(),

             Var::rte_pos(ws).value(),

             Var::rte_los(ws).value(),

             Var::rte_pos2(ws).value(),

             Var::cloudbox_on(ws).value(),

             Var::ppath_inside_cloudbox_do(ws).value(),

             Var::f_grid(ws).value(),

             Var::ppath_agenda(ws).value());

}


inline void ppath_step_agenda(Workspace& ws) {

  ppath_step_agendaExecute(ws,

             Var::ppath_step(ws).value(),

             Var::ppath_lmax(ws).value(),

             Var::ppath_lraytrace(ws).value(),

             Var::f_grid(ws).value(),

             Var::ppath_step_agenda(ws).value());

}


inline void propmat_clearsky_agenda(Workspace& ws) {

  propmat_clearsky_agendaExecute(ws,

             Var::propmat_clearsky(ws).value(),

             Var::nlte_source(ws).value(),

             Var::dpropmat_clearsky_dx(ws).value(),

             Var::dnlte_dx_source(ws).value(),

             Var::nlte_dsource_dx(ws).value(),

             Var::jacobian_quantities(ws).value(),

             Var::f_grid(ws).value(),

             Var::rtp_mag(ws).value(),

             Var::rtp_los(ws).value(),

             Var::rtp_pressure(ws).value(),

             Var::rtp_temperature(ws).value(),

             Var::rtp_nlte(ws).value(),

             Var::rtp_vmr(ws).value(),

             Var::propmat_clearsky_agenda(ws).value());

}


inline void refr_index_air_agenda(Workspace& ws) {

  refr_index_air_agendaExecute(ws,

             Var::refr_index_air(ws).value(),

             Var::refr_index_air_group(ws).value(),

             Var::rtp_pressure(ws).value(),

             Var::rtp_temperature(ws).value(),

             Var::rtp_vmr(ws).value(),

             Var::f_grid(ws).value(),

             Var::refr_index_air_agenda(ws).value());

}


inline void sensor_response_agenda(Workspace& ws) {

  sensor_response_agendaExecute(ws,

             Var::sensor_response(ws).value(),

             Var::sensor_response_f(ws).value(),

             Var::sensor_response_f_grid(ws).value(),

             Var::sensor_response_pol(ws).value(),

             Var::sensor_response_pol_grid(ws).value(),

             Var::sensor_response_dlos(ws).value(),

             Var::sensor_response_dlos_grid(ws).value(),

             Var::mblock_dlos_grid(ws).value(),

             Var::f_backend(ws).value(),

             Var::sensor_response_agenda(ws).value());

}


inline void spt_calc_agenda(Workspace& ws) {

  spt_calc_agendaExecute(ws,

             Var::ext_mat_spt(ws).value(),

             Var::abs_vec_spt(ws).value(),

             Var::scat_p_index(ws).value(),

             Var::scat_lat_index(ws).value(),

             Var::scat_lon_index(ws).value(),

             Var::rtp_temperature(ws).value(),

             Var::za_index(ws).value(),

             Var::aa_index(ws).value(),

             Var::spt_calc_agenda(ws).value());

}


inline void surface_rtprop_agenda(Workspace& ws) {

  surface_rtprop_agendaExecute(ws,

             Var::surface_skin_t(ws).value(),

             Var::surface_emission(ws).value(),

             Var::surface_los(ws).value(),

             Var::surface_rmatrix(ws).value(),

             Var::f_grid(ws).value(),

             Var::rtp_pos(ws).value(),

             Var::rtp_los(ws).value(),

             Var::surface_rtprop_agenda(ws).value());

}


inline void surface_rtprop_agenda_array(Workspace& ws) {

  surface_rtprop_agenda_arrayExecute(ws,

             Var::surface_skin_t(ws).value(),

             Var::surface_emission(ws).value(),

             Var::surface_los(ws).value(),

             Var::surface_rmatrix(ws).value(),

             Var::agenda_array_index(ws).value(),

             Var::f_grid(ws).value(),

             Var::rtp_pos(ws).value(),

             Var::rtp_los(ws).value(),

             Var::surface_type_aux(ws).value(),

             Var::surface_rtprop_agenda_array(ws).value());

}


inline void surface_rtprop_sub_agenda(Workspace& ws) {

  surface_rtprop_sub_agendaExecute(ws,

             Var::surface_skin_t(ws).value(),

             Var::surface_emission(ws).value(),

             Var::surface_los(ws).value(),

             Var::surface_rmatrix(ws).value(),

             Var::f_grid(ws).value(),

             Var::rtp_pos(ws).value(),

             Var::rtp_los(ws).value(),

             Var::surface_rtprop_sub_agenda(ws).value());

}


inline void test_agenda(Workspace& ws) {

  test_agendaExecute(ws,

             Var::test_agenda(ws).value());

}


inline void test_agenda_array(Workspace& ws) {

  test_agenda_arrayExecute(ws,

             Var::agenda_array_index(ws).value(),

             Var::iy_unit(ws).value(),

             Var::test_agenda_array(ws).value());

}


inline void water_p_eq_agenda(Workspace& ws) {

  water_p_eq_agendaExecute(ws,

             Var::water_p_eq_field(ws).value(),

             Var::t_field(ws).value(),

             Var::water_p_eq_agenda(ws).value());

}


inline void ybatch_calc_agenda(Workspace& ws) {

  ybatch_calc_agendaExecute(ws,

             Var::y(ws).value(),

             Var::y_aux(ws).value(),

             Var::jacobian(ws).value(),

             Var::ybatch_index(ws).value(),

             Var::ybatch_calc_agenda(ws).value());

}


}  // ARTS::AgendaExecute


namespace ARTS::AgendaDefine {

template <typename ... Records>

void Append(Agenda& ag, Records ... records) {

  for (auto& x: { MRecord(records)... })

    ag.push_back(x);

}


template <typename ... Records> inline

void abs_xsec_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::abs_xsec_agenda(ws).value().resize(0);

  ARTS::Var::abs_xsec_agenda(ws).value().set_name("abs_xsec_agenda");

  Append(ARTS::Var::abs_xsec_agenda(ws).value(), records...);

  Var::abs_xsec_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void dobatch_calc_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::dobatch_calc_agenda(ws).value().resize(0);

  ARTS::Var::dobatch_calc_agenda(ws).value().set_name("dobatch_calc_agenda");

  Append(ARTS::Var::dobatch_calc_agenda(ws).value(), records...);

  Var::dobatch_calc_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void doit_conv_test_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::doit_conv_test_agenda(ws).value().resize(0);

  ARTS::Var::doit_conv_test_agenda(ws).value().set_name("doit_conv_test_agenda");

  Append(ARTS::Var::doit_conv_test_agenda(ws).value(), records...);

  Var::doit_conv_test_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void doit_mono_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::doit_mono_agenda(ws).value().resize(0);

  ARTS::Var::doit_mono_agenda(ws).value().set_name("doit_mono_agenda");

  Append(ARTS::Var::doit_mono_agenda(ws).value(), records...);

  Var::doit_mono_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void doit_rte_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::doit_rte_agenda(ws).value().resize(0);

  ARTS::Var::doit_rte_agenda(ws).value().set_name("doit_rte_agenda");

  Append(ARTS::Var::doit_rte_agenda(ws).value(), records...);

  Var::doit_rte_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void doit_scat_field_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::doit_scat_field_agenda(ws).value().resize(0);

  ARTS::Var::doit_scat_field_agenda(ws).value().set_name("doit_scat_field_agenda");

  Append(ARTS::Var::doit_scat_field_agenda(ws).value(), records...);

  Var::doit_scat_field_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void forloop_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::forloop_agenda(ws).value().resize(0);

  ARTS::Var::forloop_agenda(ws).value().set_name("forloop_agenda");

  Append(ARTS::Var::forloop_agenda(ws).value(), records...);

  Var::forloop_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void g0_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::g0_agenda(ws).value().resize(0);

  ARTS::Var::g0_agenda(ws).value().set_name("g0_agenda");

  Append(ARTS::Var::g0_agenda(ws).value(), records...);

  Var::g0_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void geo_pos_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::geo_pos_agenda(ws).value().resize(0);

  ARTS::Var::geo_pos_agenda(ws).value().set_name("geo_pos_agenda");

  Append(ARTS::Var::geo_pos_agenda(ws).value(), records...);

  Var::geo_pos_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void inversion_iterate_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::inversion_iterate_agenda(ws).value().resize(0);

  ARTS::Var::inversion_iterate_agenda(ws).value().set_name("inversion_iterate_agenda");

  Append(ARTS::Var::inversion_iterate_agenda(ws).value(), records...);

  Var::inversion_iterate_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void iy_cloudbox_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::iy_cloudbox_agenda(ws).value().resize(0);

  ARTS::Var::iy_cloudbox_agenda(ws).value().set_name("iy_cloudbox_agenda");

  Append(ARTS::Var::iy_cloudbox_agenda(ws).value(), records...);

  Var::iy_cloudbox_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void iy_independent_beam_approx_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::iy_independent_beam_approx_agenda(ws).value().resize(0);

  ARTS::Var::iy_independent_beam_approx_agenda(ws).value().set_name("iy_independent_beam_approx_agenda");

  Append(ARTS::Var::iy_independent_beam_approx_agenda(ws).value(), records...);

  Var::iy_independent_beam_approx_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void iy_loop_freqs_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::iy_loop_freqs_agenda(ws).value().resize(0);

  ARTS::Var::iy_loop_freqs_agenda(ws).value().set_name("iy_loop_freqs_agenda");

  Append(ARTS::Var::iy_loop_freqs_agenda(ws).value(), records...);

  Var::iy_loop_freqs_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void iy_main_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::iy_main_agenda(ws).value().resize(0);

  ARTS::Var::iy_main_agenda(ws).value().set_name("iy_main_agenda");

  Append(ARTS::Var::iy_main_agenda(ws).value(), records...);

  Var::iy_main_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void iy_space_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::iy_space_agenda(ws).value().resize(0);

  ARTS::Var::iy_space_agenda(ws).value().set_name("iy_space_agenda");

  Append(ARTS::Var::iy_space_agenda(ws).value(), records...);

  Var::iy_space_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void iy_surface_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::iy_surface_agenda(ws).value().resize(0);

  ARTS::Var::iy_surface_agenda(ws).value().set_name("iy_surface_agenda");

  Append(ARTS::Var::iy_surface_agenda(ws).value(), records...);

  Var::iy_surface_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void iy_transmitter_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::iy_transmitter_agenda(ws).value().resize(0);

  ARTS::Var::iy_transmitter_agenda(ws).value().set_name("iy_transmitter_agenda");

  Append(ARTS::Var::iy_transmitter_agenda(ws).value(), records...);

  Var::iy_transmitter_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void jacobian_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::jacobian_agenda(ws).value().resize(0);

  ARTS::Var::jacobian_agenda(ws).value().set_name("jacobian_agenda");

  Append(ARTS::Var::jacobian_agenda(ws).value(), records...);

  Var::jacobian_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void main_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::main_agenda(ws).value().resize(0);

  ARTS::Var::main_agenda(ws).value().set_name("main_agenda");

  Append(ARTS::Var::main_agenda(ws).value(), records...);

  Var::main_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void met_profile_calc_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::met_profile_calc_agenda(ws).value().resize(0);

  ARTS::Var::met_profile_calc_agenda(ws).value().set_name("met_profile_calc_agenda");

  Append(ARTS::Var::met_profile_calc_agenda(ws).value(), records...);

  Var::met_profile_calc_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void pha_mat_spt_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::pha_mat_spt_agenda(ws).value().resize(0);

  ARTS::Var::pha_mat_spt_agenda(ws).value().set_name("pha_mat_spt_agenda");

  Append(ARTS::Var::pha_mat_spt_agenda(ws).value(), records...);

  Var::pha_mat_spt_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void ppath_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::ppath_agenda(ws).value().resize(0);

  ARTS::Var::ppath_agenda(ws).value().set_name("ppath_agenda");

  Append(ARTS::Var::ppath_agenda(ws).value(), records...);

  Var::ppath_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void ppath_step_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::ppath_step_agenda(ws).value().resize(0);

  ARTS::Var::ppath_step_agenda(ws).value().set_name("ppath_step_agenda");

  Append(ARTS::Var::ppath_step_agenda(ws).value(), records...);

  Var::ppath_step_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void propmat_clearsky_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::propmat_clearsky_agenda(ws).value().resize(0);

  ARTS::Var::propmat_clearsky_agenda(ws).value().set_name("propmat_clearsky_agenda");

  Append(ARTS::Var::propmat_clearsky_agenda(ws).value(), records...);

  Var::propmat_clearsky_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void refr_index_air_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::refr_index_air_agenda(ws).value().resize(0);

  ARTS::Var::refr_index_air_agenda(ws).value().set_name("refr_index_air_agenda");

  Append(ARTS::Var::refr_index_air_agenda(ws).value(), records...);

  Var::refr_index_air_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void sensor_response_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::sensor_response_agenda(ws).value().resize(0);

  ARTS::Var::sensor_response_agenda(ws).value().set_name("sensor_response_agenda");

  Append(ARTS::Var::sensor_response_agenda(ws).value(), records...);

  Var::sensor_response_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void spt_calc_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::spt_calc_agenda(ws).value().resize(0);

  ARTS::Var::spt_calc_agenda(ws).value().set_name("spt_calc_agenda");

  Append(ARTS::Var::spt_calc_agenda(ws).value(), records...);

  Var::spt_calc_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void surface_rtprop_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::surface_rtprop_agenda(ws).value().resize(0);

  ARTS::Var::surface_rtprop_agenda(ws).value().set_name("surface_rtprop_agenda");

  Append(ARTS::Var::surface_rtprop_agenda(ws).value(), records...);

  Var::surface_rtprop_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void surface_rtprop_sub_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::surface_rtprop_sub_agenda(ws).value().resize(0);

  ARTS::Var::surface_rtprop_sub_agenda(ws).value().set_name("surface_rtprop_sub_agenda");

  Append(ARTS::Var::surface_rtprop_sub_agenda(ws).value(), records...);

  Var::surface_rtprop_sub_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void test_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::test_agenda(ws).value().resize(0);

  ARTS::Var::test_agenda(ws).value().set_name("test_agenda");

  Append(ARTS::Var::test_agenda(ws).value(), records...);

  Var::test_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void water_p_eq_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::water_p_eq_agenda(ws).value().resize(0);

  ARTS::Var::water_p_eq_agenda(ws).value().set_name("water_p_eq_agenda");

  Append(ARTS::Var::water_p_eq_agenda(ws).value(), records...);

  Var::water_p_eq_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


template <typename ... Records> inline

void ybatch_calc_agenda(Workspace& ws, Records ... records) {

  ARTS::Var::ybatch_calc_agenda(ws).value().resize(0);

  ARTS::Var::ybatch_calc_agenda(ws).value().set_name("ybatch_calc_agenda");

  Append(ARTS::Var::ybatch_calc_agenda(ws).value(), records...);

  Var::ybatch_calc_agenda(ws).value().check(ws, Var::verbosity(ws).value());

}


}  // ARTS::AgendaDefine


namespace ARTS {

inline Workspace init(std::size_t screen=0, std::size_t file=0, std::size_t agenda=0, const Group::String& basename="arts", int numthreads=0) {

  omp_set_num_threads(numthreads < 1 ? arts_omp_get_max_threads() : numthreads > arts_omp_get_max_threads() ? arts_omp_get_max_threads() : numthreads);


  define_wsv_group_names();

  Workspace::define_wsv_data();

  Workspace::define_wsv_map();

  define_md_data_raw();

  expand_md_data_raw_to_md_data();

  define_md_map();

  define_agenda_data();

  define_agenda_map();

  define_species_data();

  define_species_map();

  global_data::workspace_memory_handler.initialize();


  Workspace ws;

  ws.initialize();

  Var::verbosity(ws).value().set_screen_verbosity(screen);

  Var::verbosity(ws).value().set_agenda_verbosity(agenda);

  Var::verbosity(ws).value().set_file_verbosity(file);

  Var::verbosity(ws).value().set_main_agenda(1);


  out_basename = basename;


  #ifndef NDEBUG

  ws.context = "";

  #endif


  return ws;

}

}  // namespace::ARTS


#endif  // autoarts_h