workspace_memory_handler.cc

Go to the documentation of this file.

 
#include "workspace_memory_handler.h"
#include <iostream>
#include "matpackII.h"
#include "m_general.h"
#include "supergeneric.h"
#include "artstime.h"
#include "ppath.h"
#include "gas_abs_lookup.h"
#include "linemixing_hitran.h"
#include "optproperties.h"
#include "gridded_fields.h"
#include "jacobian.h"
#include "agenda_class.h"
#include "mc_interp.h"
#include "mc_antenna.h"
#include "cia.h"
#include "propagationmatrix.h"
#include "transmissionmatrix.h"
#include "covariance_matrix.h"
#include "telsem.h"
#include "tessem.h"
#include "xsec_fit.h"
#include "absorptionlines.h"
#include "linemixing.h"
#include "callback.h"
 
// Allocation and deallocation routines for workspace groups
std::shared_ptr<void> allocate_wsvg_AbsorptionLines(){
  return std::make_shared<AbsorptionLines>();
}
std::shared_ptr<void> duplicate_wsvg_AbsorptionLines(const std::shared_ptr<void>& vp) {  return std::make_shared<AbsorptionLines>(*static_cast<AbsorptionLines*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Agenda(){
  return std::make_shared<Agenda>();
}
std::shared_ptr<void> duplicate_wsvg_Agenda(const std::shared_ptr<void>& vp) {  return std::make_shared<Agenda>(*static_cast<Agenda*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Any(){
  return std::make_shared<Any>();
}
std::shared_ptr<void> duplicate_wsvg_Any(const std::shared_ptr<void>& vp) {  return std::make_shared<Any>(*static_cast<Any*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfAbsorptionLines(){
  return std::make_shared<ArrayOfAbsorptionLines>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfAbsorptionLines(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfAbsorptionLines>(*static_cast<ArrayOfAbsorptionLines*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfAgenda(){
  return std::make_shared<ArrayOfAgenda>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfAgenda(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfAgenda>(*static_cast<ArrayOfAgenda*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfAbsorptionLines(){
  return std::make_shared<ArrayOfArrayOfAbsorptionLines>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfAbsorptionLines(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfAbsorptionLines>(*static_cast<ArrayOfArrayOfAbsorptionLines*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfGriddedField1(){
  return std::make_shared<ArrayOfArrayOfGriddedField1>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfGriddedField1(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfGriddedField1>(*static_cast<ArrayOfArrayOfGriddedField1*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfGriddedField2(){
  return std::make_shared<ArrayOfArrayOfGriddedField2>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfGriddedField2(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfGriddedField2>(*static_cast<ArrayOfArrayOfGriddedField2*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfGriddedField3(){
  return std::make_shared<ArrayOfArrayOfGriddedField3>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfGriddedField3(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfGriddedField3>(*static_cast<ArrayOfArrayOfGriddedField3*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfIndex(){
  return std::make_shared<ArrayOfArrayOfIndex>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfIndex(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfIndex>(*static_cast<ArrayOfArrayOfIndex*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfMatrix(){
  return std::make_shared<ArrayOfArrayOfMatrix>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfMatrix(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfMatrix>(*static_cast<ArrayOfArrayOfMatrix*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfPropagationMatrix(){
  return std::make_shared<ArrayOfArrayOfPropagationMatrix>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfPropagationMatrix(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfPropagationMatrix>(*static_cast<ArrayOfArrayOfPropagationMatrix*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfRadiationVector(){
  return std::make_shared<ArrayOfArrayOfRadiationVector>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfRadiationVector(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfRadiationVector>(*static_cast<ArrayOfArrayOfRadiationVector*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfScatteringMetaData(){
  return std::make_shared<ArrayOfArrayOfScatteringMetaData>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfScatteringMetaData(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfScatteringMetaData>(*static_cast<ArrayOfArrayOfScatteringMetaData*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfSingleScatteringData(){
  return std::make_shared<ArrayOfArrayOfSingleScatteringData>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfSingleScatteringData(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfSingleScatteringData>(*static_cast<ArrayOfArrayOfSingleScatteringData*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfSpeciesTag(){
  return std::make_shared<ArrayOfArrayOfSpeciesTag>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfSpeciesTag(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfSpeciesTag>(*static_cast<ArrayOfArrayOfSpeciesTag*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfStokesVector(){
  return std::make_shared<ArrayOfArrayOfStokesVector>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfStokesVector(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfStokesVector>(*static_cast<ArrayOfArrayOfStokesVector*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfString(){
  return std::make_shared<ArrayOfArrayOfString>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfString(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfString>(*static_cast<ArrayOfArrayOfString*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfTensor3(){
  return std::make_shared<ArrayOfArrayOfTensor3>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfTensor3(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfTensor3>(*static_cast<ArrayOfArrayOfTensor3*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfTensor6(){
  return std::make_shared<ArrayOfArrayOfTensor6>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfTensor6(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfTensor6>(*static_cast<ArrayOfArrayOfTensor6*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfTime(){
  return std::make_shared<ArrayOfArrayOfTime>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfTime(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfTime>(*static_cast<ArrayOfArrayOfTime*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfTransmissionMatrix(){
  return std::make_shared<ArrayOfArrayOfTransmissionMatrix>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfTransmissionMatrix(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfTransmissionMatrix>(*static_cast<ArrayOfArrayOfTransmissionMatrix*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfArrayOfVector(){
  return std::make_shared<ArrayOfArrayOfVector>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfArrayOfVector(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfArrayOfVector>(*static_cast<ArrayOfArrayOfVector*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfCIARecord(){
  return std::make_shared<ArrayOfCIARecord>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfCIARecord(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfCIARecord>(*static_cast<ArrayOfCIARecord*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfGriddedField1(){
  return std::make_shared<ArrayOfGriddedField1>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfGriddedField1(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfGriddedField1>(*static_cast<ArrayOfGriddedField1*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfGriddedField2(){
  return std::make_shared<ArrayOfGriddedField2>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfGriddedField2(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfGriddedField2>(*static_cast<ArrayOfGriddedField2*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfGriddedField3(){
  return std::make_shared<ArrayOfGriddedField3>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfGriddedField3(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfGriddedField3>(*static_cast<ArrayOfGriddedField3*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfGriddedField4(){
  return std::make_shared<ArrayOfGriddedField4>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfGriddedField4(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfGriddedField4>(*static_cast<ArrayOfGriddedField4*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfIndex(){
  return std::make_shared<ArrayOfIndex>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfIndex(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfIndex>(*static_cast<ArrayOfIndex*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfJacobianTarget(){
  return std::make_shared<ArrayOfJacobianTarget>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfJacobianTarget(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfJacobianTarget>(*static_cast<ArrayOfJacobianTarget*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfMatrix(){
  return std::make_shared<ArrayOfMatrix>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfMatrix(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfMatrix>(*static_cast<ArrayOfMatrix*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfPpath(){
  return std::make_shared<ArrayOfPpath>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfPpath(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfPpath>(*static_cast<ArrayOfPpath*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfPropagationMatrix(){
  return std::make_shared<ArrayOfPropagationMatrix>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfPropagationMatrix(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfPropagationMatrix>(*static_cast<ArrayOfPropagationMatrix*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfQuantumIdentifier(){
  return std::make_shared<ArrayOfQuantumIdentifier>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfQuantumIdentifier(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfQuantumIdentifier>(*static_cast<ArrayOfQuantumIdentifier*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfRadiationVector(){
  return std::make_shared<ArrayOfRadiationVector>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfRadiationVector(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfRadiationVector>(*static_cast<ArrayOfRadiationVector*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfRetrievalQuantity(){
  return std::make_shared<ArrayOfRetrievalQuantity>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfRetrievalQuantity(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfRetrievalQuantity>(*static_cast<ArrayOfRetrievalQuantity*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfScatteringMetaData(){
  return std::make_shared<ArrayOfScatteringMetaData>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfScatteringMetaData(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfScatteringMetaData>(*static_cast<ArrayOfScatteringMetaData*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfSingleScatteringData(){
  return std::make_shared<ArrayOfSingleScatteringData>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfSingleScatteringData(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfSingleScatteringData>(*static_cast<ArrayOfSingleScatteringData*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfSparse(){
  return std::make_shared<ArrayOfSparse>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfSparse(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfSparse>(*static_cast<ArrayOfSparse*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfSpeciesTag(){
  return std::make_shared<ArrayOfSpeciesTag>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfSpeciesTag(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfSpeciesTag>(*static_cast<ArrayOfSpeciesTag*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfStokesVector(){
  return std::make_shared<ArrayOfStokesVector>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfStokesVector(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfStokesVector>(*static_cast<ArrayOfStokesVector*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfString(){
  return std::make_shared<ArrayOfString>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfString(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfString>(*static_cast<ArrayOfString*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfTelsemAtlas(){
  return std::make_shared<ArrayOfTelsemAtlas>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfTelsemAtlas(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfTelsemAtlas>(*static_cast<ArrayOfTelsemAtlas*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfTensor3(){
  return std::make_shared<ArrayOfTensor3>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfTensor3(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfTensor3>(*static_cast<ArrayOfTensor3*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfTensor4(){
  return std::make_shared<ArrayOfTensor4>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfTensor4(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfTensor4>(*static_cast<ArrayOfTensor4*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfTensor5(){
  return std::make_shared<ArrayOfTensor5>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfTensor5(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfTensor5>(*static_cast<ArrayOfTensor5*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfTensor6(){
  return std::make_shared<ArrayOfTensor6>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfTensor6(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfTensor6>(*static_cast<ArrayOfTensor6*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfTensor7(){
  return std::make_shared<ArrayOfTensor7>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfTensor7(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfTensor7>(*static_cast<ArrayOfTensor7*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfTime(){
  return std::make_shared<ArrayOfTime>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfTime(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfTime>(*static_cast<ArrayOfTime*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfTransmissionMatrix(){
  return std::make_shared<ArrayOfTransmissionMatrix>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfTransmissionMatrix(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfTransmissionMatrix>(*static_cast<ArrayOfTransmissionMatrix*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfVector(){
  return std::make_shared<ArrayOfVector>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfVector(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfVector>(*static_cast<ArrayOfVector*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ArrayOfXsecRecord(){
  return std::make_shared<ArrayOfXsecRecord>();
}
std::shared_ptr<void> duplicate_wsvg_ArrayOfXsecRecord(const std::shared_ptr<void>& vp) {  return std::make_shared<ArrayOfXsecRecord>(*static_cast<ArrayOfXsecRecord*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_CIARecord(){
  return std::make_shared<CIARecord>();
}
std::shared_ptr<void> duplicate_wsvg_CIARecord(const std::shared_ptr<void>& vp) {  return std::make_shared<CIARecord>(*static_cast<CIARecord*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_CallbackFunction(){
  return std::make_shared<CallbackFunction>();
}
std::shared_ptr<void> duplicate_wsvg_CallbackFunction(const std::shared_ptr<void>& vp) {  return std::make_shared<CallbackFunction>(*static_cast<CallbackFunction*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_CovarianceMatrix(){
  return std::make_shared<CovarianceMatrix>();
}
std::shared_ptr<void> duplicate_wsvg_CovarianceMatrix(const std::shared_ptr<void>& vp) {  return std::make_shared<CovarianceMatrix>(*static_cast<CovarianceMatrix*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_EnergyLevelMap(){
  return std::make_shared<EnergyLevelMap>();
}
std::shared_ptr<void> duplicate_wsvg_EnergyLevelMap(const std::shared_ptr<void>& vp) {  return std::make_shared<EnergyLevelMap>(*static_cast<EnergyLevelMap*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_GasAbsLookup(){
  return std::make_shared<GasAbsLookup>();
}
std::shared_ptr<void> duplicate_wsvg_GasAbsLookup(const std::shared_ptr<void>& vp) {  return std::make_shared<GasAbsLookup>(*static_cast<GasAbsLookup*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_GridPos(){
  return std::make_shared<GridPos>();
}
std::shared_ptr<void> duplicate_wsvg_GridPos(const std::shared_ptr<void>& vp) {  return std::make_shared<GridPos>(*static_cast<GridPos*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_GriddedField1(){
  return std::make_shared<GriddedField1>();
}
std::shared_ptr<void> duplicate_wsvg_GriddedField1(const std::shared_ptr<void>& vp) {  return std::make_shared<GriddedField1>(*static_cast<GriddedField1*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_GriddedField2(){
  return std::make_shared<GriddedField2>();
}
std::shared_ptr<void> duplicate_wsvg_GriddedField2(const std::shared_ptr<void>& vp) {  return std::make_shared<GriddedField2>(*static_cast<GriddedField2*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_GriddedField3(){
  return std::make_shared<GriddedField3>();
}
std::shared_ptr<void> duplicate_wsvg_GriddedField3(const std::shared_ptr<void>& vp) {  return std::make_shared<GriddedField3>(*static_cast<GriddedField3*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_GriddedField4(){
  return std::make_shared<GriddedField4>();
}
std::shared_ptr<void> duplicate_wsvg_GriddedField4(const std::shared_ptr<void>& vp) {  return std::make_shared<GriddedField4>(*static_cast<GriddedField4*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_GriddedField5(){
  return std::make_shared<GriddedField5>();
}
std::shared_ptr<void> duplicate_wsvg_GriddedField5(const std::shared_ptr<void>& vp) {  return std::make_shared<GriddedField5>(*static_cast<GriddedField5*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_GriddedField6(){
  return std::make_shared<GriddedField6>();
}
std::shared_ptr<void> duplicate_wsvg_GriddedField6(const std::shared_ptr<void>& vp) {  return std::make_shared<GriddedField6>(*static_cast<GriddedField6*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_HitranRelaxationMatrixData(){
  return std::make_shared<HitranRelaxationMatrixData>();
}
std::shared_ptr<void> duplicate_wsvg_HitranRelaxationMatrixData(const std::shared_ptr<void>& vp) {  return std::make_shared<HitranRelaxationMatrixData>(*static_cast<HitranRelaxationMatrixData*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Index(){
  return std::make_shared<Index>();
}
std::shared_ptr<void> duplicate_wsvg_Index(const std::shared_ptr<void>& vp) {  return std::make_shared<Index>(*static_cast<Index*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_JacobianTarget(){
  return std::make_shared<JacobianTarget>();
}
std::shared_ptr<void> duplicate_wsvg_JacobianTarget(const std::shared_ptr<void>& vp) {  return std::make_shared<JacobianTarget>(*static_cast<JacobianTarget*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_MCAntenna(){
  return std::make_shared<MCAntenna>();
}
std::shared_ptr<void> duplicate_wsvg_MCAntenna(const std::shared_ptr<void>& vp) {  return std::make_shared<MCAntenna>(*static_cast<MCAntenna*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_MapOfErrorCorrectedSuddenData(){
  return std::make_shared<MapOfErrorCorrectedSuddenData>();
}
std::shared_ptr<void> duplicate_wsvg_MapOfErrorCorrectedSuddenData(const std::shared_ptr<void>& vp) {  return std::make_shared<MapOfErrorCorrectedSuddenData>(*static_cast<MapOfErrorCorrectedSuddenData*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Matrix(){
  return std::make_shared<Matrix>();
}
std::shared_ptr<void> duplicate_wsvg_Matrix(const std::shared_ptr<void>& vp) {  return std::make_shared<Matrix>(*static_cast<Matrix*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Numeric(){
  return std::make_shared<Numeric>();
}
std::shared_ptr<void> duplicate_wsvg_Numeric(const std::shared_ptr<void>& vp) {  return std::make_shared<Numeric>(*static_cast<Numeric*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Ppath(){
  return std::make_shared<Ppath>();
}
std::shared_ptr<void> duplicate_wsvg_Ppath(const std::shared_ptr<void>& vp) {  return std::make_shared<Ppath>(*static_cast<Ppath*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_PredefinedModelData(){
  return std::make_shared<PredefinedModelData>();
}
std::shared_ptr<void> duplicate_wsvg_PredefinedModelData(const std::shared_ptr<void>& vp) {  return std::make_shared<PredefinedModelData>(*static_cast<PredefinedModelData*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_PropagationMatrix(){
  return std::make_shared<PropagationMatrix>();
}
std::shared_ptr<void> duplicate_wsvg_PropagationMatrix(const std::shared_ptr<void>& vp) {  return std::make_shared<PropagationMatrix>(*static_cast<PropagationMatrix*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_QuantumIdentifier(){
  return std::make_shared<QuantumIdentifier>();
}
std::shared_ptr<void> duplicate_wsvg_QuantumIdentifier(const std::shared_ptr<void>& vp) {  return std::make_shared<QuantumIdentifier>(*static_cast<QuantumIdentifier*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_RadiationVector(){
  return std::make_shared<RadiationVector>();
}
std::shared_ptr<void> duplicate_wsvg_RadiationVector(const std::shared_ptr<void>& vp) {  return std::make_shared<RadiationVector>(*static_cast<RadiationVector*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Rational(){
  return std::make_shared<Rational>();
}
std::shared_ptr<void> duplicate_wsvg_Rational(const std::shared_ptr<void>& vp) {  return std::make_shared<Rational>(*static_cast<Rational*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_ScatteringMetaData(){
  return std::make_shared<ScatteringMetaData>();
}
std::shared_ptr<void> duplicate_wsvg_ScatteringMetaData(const std::shared_ptr<void>& vp) {  return std::make_shared<ScatteringMetaData>(*static_cast<ScatteringMetaData*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_SingleScatteringData(){
  return std::make_shared<SingleScatteringData>();
}
std::shared_ptr<void> duplicate_wsvg_SingleScatteringData(const std::shared_ptr<void>& vp) {  return std::make_shared<SingleScatteringData>(*static_cast<SingleScatteringData*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Sparse(){
  return std::make_shared<Sparse>();
}
std::shared_ptr<void> duplicate_wsvg_Sparse(const std::shared_ptr<void>& vp) {  return std::make_shared<Sparse>(*static_cast<Sparse*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_SpeciesIsotopologueRatios(){
  return std::make_shared<SpeciesIsotopologueRatios>();
}
std::shared_ptr<void> duplicate_wsvg_SpeciesIsotopologueRatios(const std::shared_ptr<void>& vp) {  return std::make_shared<SpeciesIsotopologueRatios>(*static_cast<SpeciesIsotopologueRatios*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_StokesVector(){
  return std::make_shared<StokesVector>();
}
std::shared_ptr<void> duplicate_wsvg_StokesVector(const std::shared_ptr<void>& vp) {  return std::make_shared<StokesVector>(*static_cast<StokesVector*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_String(){
  return std::make_shared<String>();
}
std::shared_ptr<void> duplicate_wsvg_String(const std::shared_ptr<void>& vp) {  return std::make_shared<String>(*static_cast<String*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_TelsemAtlas(){
  return std::make_shared<TelsemAtlas>();
}
std::shared_ptr<void> duplicate_wsvg_TelsemAtlas(const std::shared_ptr<void>& vp) {  return std::make_shared<TelsemAtlas>(*static_cast<TelsemAtlas*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Tensor3(){
  return std::make_shared<Tensor3>();
}
std::shared_ptr<void> duplicate_wsvg_Tensor3(const std::shared_ptr<void>& vp) {  return std::make_shared<Tensor3>(*static_cast<Tensor3*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Tensor4(){
  return std::make_shared<Tensor4>();
}
std::shared_ptr<void> duplicate_wsvg_Tensor4(const std::shared_ptr<void>& vp) {  return std::make_shared<Tensor4>(*static_cast<Tensor4*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Tensor5(){
  return std::make_shared<Tensor5>();
}
std::shared_ptr<void> duplicate_wsvg_Tensor5(const std::shared_ptr<void>& vp) {  return std::make_shared<Tensor5>(*static_cast<Tensor5*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Tensor6(){
  return std::make_shared<Tensor6>();
}
std::shared_ptr<void> duplicate_wsvg_Tensor6(const std::shared_ptr<void>& vp) {  return std::make_shared<Tensor6>(*static_cast<Tensor6*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Tensor7(){
  return std::make_shared<Tensor7>();
}
std::shared_ptr<void> duplicate_wsvg_Tensor7(const std::shared_ptr<void>& vp) {  return std::make_shared<Tensor7>(*static_cast<Tensor7*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_TessemNN(){
  return std::make_shared<TessemNN>();
}
std::shared_ptr<void> duplicate_wsvg_TessemNN(const std::shared_ptr<void>& vp) {  return std::make_shared<TessemNN>(*static_cast<TessemNN*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Time(){
  return std::make_shared<Time>();
}
std::shared_ptr<void> duplicate_wsvg_Time(const std::shared_ptr<void>& vp) {  return std::make_shared<Time>(*static_cast<Time*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Timer(){
  return std::make_shared<Timer>();
}
std::shared_ptr<void> duplicate_wsvg_Timer(const std::shared_ptr<void>& vp) {  return std::make_shared<Timer>(*static_cast<Timer*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_TransmissionMatrix(){
  return std::make_shared<TransmissionMatrix>();
}
std::shared_ptr<void> duplicate_wsvg_TransmissionMatrix(const std::shared_ptr<void>& vp) {  return std::make_shared<TransmissionMatrix>(*static_cast<TransmissionMatrix*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Vector(){
  return std::make_shared<Vector>();
}
std::shared_ptr<void> duplicate_wsvg_Vector(const std::shared_ptr<void>& vp) {  return std::make_shared<Vector>(*static_cast<Vector*>(vp.get()));
}
 
std::shared_ptr<void> allocate_wsvg_Verbosity(){
  return std::make_shared<Verbosity>();
}
std::shared_ptr<void> duplicate_wsvg_Verbosity(const std::shared_ptr<void>& vp) {  return std::make_shared<Verbosity>(*static_cast<Verbosity*>(vp.get()));
}
 
void WorkspaceMemoryHandler::initialize() {
  allocation_ptrs_.resize(95);
  duplication_ptrs_.resize(95);
 
  allocation_ptrs_[0] = allocate_wsvg_AbsorptionLines;
  duplication_ptrs_[0] = duplicate_wsvg_AbsorptionLines;
  allocation_ptrs_[1] = allocate_wsvg_Agenda;
  duplication_ptrs_[1] = duplicate_wsvg_Agenda;
  allocation_ptrs_[2] = allocate_wsvg_Any;
  duplication_ptrs_[2] = duplicate_wsvg_Any;
  allocation_ptrs_[3] = allocate_wsvg_ArrayOfAbsorptionLines;
  duplication_ptrs_[3] = duplicate_wsvg_ArrayOfAbsorptionLines;
  allocation_ptrs_[4] = allocate_wsvg_ArrayOfAgenda;
  duplication_ptrs_[4] = duplicate_wsvg_ArrayOfAgenda;
  allocation_ptrs_[5] = allocate_wsvg_ArrayOfArrayOfAbsorptionLines;
  duplication_ptrs_[5] = duplicate_wsvg_ArrayOfArrayOfAbsorptionLines;
  allocation_ptrs_[6] = allocate_wsvg_ArrayOfArrayOfGriddedField1;
  duplication_ptrs_[6] = duplicate_wsvg_ArrayOfArrayOfGriddedField1;
  allocation_ptrs_[7] = allocate_wsvg_ArrayOfArrayOfGriddedField2;
  duplication_ptrs_[7] = duplicate_wsvg_ArrayOfArrayOfGriddedField2;
  allocation_ptrs_[8] = allocate_wsvg_ArrayOfArrayOfGriddedField3;
  duplication_ptrs_[8] = duplicate_wsvg_ArrayOfArrayOfGriddedField3;
  allocation_ptrs_[9] = allocate_wsvg_ArrayOfArrayOfIndex;
  duplication_ptrs_[9] = duplicate_wsvg_ArrayOfArrayOfIndex;
  allocation_ptrs_[10] = allocate_wsvg_ArrayOfArrayOfMatrix;
  duplication_ptrs_[10] = duplicate_wsvg_ArrayOfArrayOfMatrix;
  allocation_ptrs_[11] = allocate_wsvg_ArrayOfArrayOfPropagationMatrix;
  duplication_ptrs_[11] = duplicate_wsvg_ArrayOfArrayOfPropagationMatrix;
  allocation_ptrs_[12] = allocate_wsvg_ArrayOfArrayOfRadiationVector;
  duplication_ptrs_[12] = duplicate_wsvg_ArrayOfArrayOfRadiationVector;
  allocation_ptrs_[13] = allocate_wsvg_ArrayOfArrayOfScatteringMetaData;
  duplication_ptrs_[13] = duplicate_wsvg_ArrayOfArrayOfScatteringMetaData;
  allocation_ptrs_[14] = allocate_wsvg_ArrayOfArrayOfSingleScatteringData;
  duplication_ptrs_[14] = duplicate_wsvg_ArrayOfArrayOfSingleScatteringData;
  allocation_ptrs_[15] = allocate_wsvg_ArrayOfArrayOfSpeciesTag;
  duplication_ptrs_[15] = duplicate_wsvg_ArrayOfArrayOfSpeciesTag;
  allocation_ptrs_[16] = allocate_wsvg_ArrayOfArrayOfStokesVector;
  duplication_ptrs_[16] = duplicate_wsvg_ArrayOfArrayOfStokesVector;
  allocation_ptrs_[17] = allocate_wsvg_ArrayOfArrayOfString;
  duplication_ptrs_[17] = duplicate_wsvg_ArrayOfArrayOfString;
  allocation_ptrs_[18] = allocate_wsvg_ArrayOfArrayOfTensor3;
  duplication_ptrs_[18] = duplicate_wsvg_ArrayOfArrayOfTensor3;
  allocation_ptrs_[19] = allocate_wsvg_ArrayOfArrayOfTensor6;
  duplication_ptrs_[19] = duplicate_wsvg_ArrayOfArrayOfTensor6;
  allocation_ptrs_[20] = allocate_wsvg_ArrayOfArrayOfTime;
  duplication_ptrs_[20] = duplicate_wsvg_ArrayOfArrayOfTime;
  allocation_ptrs_[21] = allocate_wsvg_ArrayOfArrayOfTransmissionMatrix;
  duplication_ptrs_[21] = duplicate_wsvg_ArrayOfArrayOfTransmissionMatrix;
  allocation_ptrs_[22] = allocate_wsvg_ArrayOfArrayOfVector;
  duplication_ptrs_[22] = duplicate_wsvg_ArrayOfArrayOfVector;
  allocation_ptrs_[23] = allocate_wsvg_ArrayOfCIARecord;
  duplication_ptrs_[23] = duplicate_wsvg_ArrayOfCIARecord;
  allocation_ptrs_[24] = allocate_wsvg_ArrayOfGriddedField1;
  duplication_ptrs_[24] = duplicate_wsvg_ArrayOfGriddedField1;
  allocation_ptrs_[25] = allocate_wsvg_ArrayOfGriddedField2;
  duplication_ptrs_[25] = duplicate_wsvg_ArrayOfGriddedField2;
  allocation_ptrs_[26] = allocate_wsvg_ArrayOfGriddedField3;
  duplication_ptrs_[26] = duplicate_wsvg_ArrayOfGriddedField3;
  allocation_ptrs_[27] = allocate_wsvg_ArrayOfGriddedField4;
  duplication_ptrs_[27] = duplicate_wsvg_ArrayOfGriddedField4;
  allocation_ptrs_[28] = allocate_wsvg_ArrayOfIndex;
  duplication_ptrs_[28] = duplicate_wsvg_ArrayOfIndex;
  allocation_ptrs_[29] = allocate_wsvg_ArrayOfJacobianTarget;
  duplication_ptrs_[29] = duplicate_wsvg_ArrayOfJacobianTarget;
  allocation_ptrs_[30] = allocate_wsvg_ArrayOfMatrix;
  duplication_ptrs_[30] = duplicate_wsvg_ArrayOfMatrix;
  allocation_ptrs_[31] = allocate_wsvg_ArrayOfPpath;
  duplication_ptrs_[31] = duplicate_wsvg_ArrayOfPpath;
  allocation_ptrs_[32] = allocate_wsvg_ArrayOfPropagationMatrix;
  duplication_ptrs_[32] = duplicate_wsvg_ArrayOfPropagationMatrix;
  allocation_ptrs_[33] = allocate_wsvg_ArrayOfQuantumIdentifier;
  duplication_ptrs_[33] = duplicate_wsvg_ArrayOfQuantumIdentifier;
  allocation_ptrs_[34] = allocate_wsvg_ArrayOfRadiationVector;
  duplication_ptrs_[34] = duplicate_wsvg_ArrayOfRadiationVector;
  allocation_ptrs_[35] = allocate_wsvg_ArrayOfRetrievalQuantity;
  duplication_ptrs_[35] = duplicate_wsvg_ArrayOfRetrievalQuantity;
  allocation_ptrs_[36] = allocate_wsvg_ArrayOfScatteringMetaData;
  duplication_ptrs_[36] = duplicate_wsvg_ArrayOfScatteringMetaData;
  allocation_ptrs_[37] = allocate_wsvg_ArrayOfSingleScatteringData;
  duplication_ptrs_[37] = duplicate_wsvg_ArrayOfSingleScatteringData;
  allocation_ptrs_[38] = allocate_wsvg_ArrayOfSparse;
  duplication_ptrs_[38] = duplicate_wsvg_ArrayOfSparse;
  allocation_ptrs_[39] = allocate_wsvg_ArrayOfSpeciesTag;
  duplication_ptrs_[39] = duplicate_wsvg_ArrayOfSpeciesTag;
  allocation_ptrs_[40] = allocate_wsvg_ArrayOfStokesVector;
  duplication_ptrs_[40] = duplicate_wsvg_ArrayOfStokesVector;
  allocation_ptrs_[41] = allocate_wsvg_ArrayOfString;
  duplication_ptrs_[41] = duplicate_wsvg_ArrayOfString;
  allocation_ptrs_[42] = allocate_wsvg_ArrayOfTelsemAtlas;
  duplication_ptrs_[42] = duplicate_wsvg_ArrayOfTelsemAtlas;
  allocation_ptrs_[43] = allocate_wsvg_ArrayOfTensor3;
  duplication_ptrs_[43] = duplicate_wsvg_ArrayOfTensor3;
  allocation_ptrs_[44] = allocate_wsvg_ArrayOfTensor4;
  duplication_ptrs_[44] = duplicate_wsvg_ArrayOfTensor4;
  allocation_ptrs_[45] = allocate_wsvg_ArrayOfTensor5;
  duplication_ptrs_[45] = duplicate_wsvg_ArrayOfTensor5;
  allocation_ptrs_[46] = allocate_wsvg_ArrayOfTensor6;
  duplication_ptrs_[46] = duplicate_wsvg_ArrayOfTensor6;
  allocation_ptrs_[47] = allocate_wsvg_ArrayOfTensor7;
  duplication_ptrs_[47] = duplicate_wsvg_ArrayOfTensor7;
  allocation_ptrs_[48] = allocate_wsvg_ArrayOfTime;
  duplication_ptrs_[48] = duplicate_wsvg_ArrayOfTime;
  allocation_ptrs_[49] = allocate_wsvg_ArrayOfTransmissionMatrix;
  duplication_ptrs_[49] = duplicate_wsvg_ArrayOfTransmissionMatrix;
  allocation_ptrs_[50] = allocate_wsvg_ArrayOfVector;
  duplication_ptrs_[50] = duplicate_wsvg_ArrayOfVector;
  allocation_ptrs_[51] = allocate_wsvg_ArrayOfXsecRecord;
  duplication_ptrs_[51] = duplicate_wsvg_ArrayOfXsecRecord;
  allocation_ptrs_[52] = allocate_wsvg_CIARecord;
  duplication_ptrs_[52] = duplicate_wsvg_CIARecord;
  allocation_ptrs_[53] = allocate_wsvg_CallbackFunction;
  duplication_ptrs_[53] = duplicate_wsvg_CallbackFunction;
  allocation_ptrs_[54] = allocate_wsvg_CovarianceMatrix;
  duplication_ptrs_[54] = duplicate_wsvg_CovarianceMatrix;
  allocation_ptrs_[55] = allocate_wsvg_EnergyLevelMap;
  duplication_ptrs_[55] = duplicate_wsvg_EnergyLevelMap;
  allocation_ptrs_[56] = allocate_wsvg_GasAbsLookup;
  duplication_ptrs_[56] = duplicate_wsvg_GasAbsLookup;
  allocation_ptrs_[57] = allocate_wsvg_GridPos;
  duplication_ptrs_[57] = duplicate_wsvg_GridPos;
  allocation_ptrs_[58] = allocate_wsvg_GriddedField1;
  duplication_ptrs_[58] = duplicate_wsvg_GriddedField1;
  allocation_ptrs_[59] = allocate_wsvg_GriddedField2;
  duplication_ptrs_[59] = duplicate_wsvg_GriddedField2;
  allocation_ptrs_[60] = allocate_wsvg_GriddedField3;
  duplication_ptrs_[60] = duplicate_wsvg_GriddedField3;
  allocation_ptrs_[61] = allocate_wsvg_GriddedField4;
  duplication_ptrs_[61] = duplicate_wsvg_GriddedField4;
  allocation_ptrs_[62] = allocate_wsvg_GriddedField5;
  duplication_ptrs_[62] = duplicate_wsvg_GriddedField5;
  allocation_ptrs_[63] = allocate_wsvg_GriddedField6;
  duplication_ptrs_[63] = duplicate_wsvg_GriddedField6;
  allocation_ptrs_[64] = allocate_wsvg_HitranRelaxationMatrixData;
  duplication_ptrs_[64] = duplicate_wsvg_HitranRelaxationMatrixData;
  allocation_ptrs_[65] = allocate_wsvg_Index;
  duplication_ptrs_[65] = duplicate_wsvg_Index;
  allocation_ptrs_[66] = allocate_wsvg_JacobianTarget;
  duplication_ptrs_[66] = duplicate_wsvg_JacobianTarget;
  allocation_ptrs_[67] = allocate_wsvg_MCAntenna;
  duplication_ptrs_[67] = duplicate_wsvg_MCAntenna;
  allocation_ptrs_[68] = allocate_wsvg_MapOfErrorCorrectedSuddenData;
  duplication_ptrs_[68] = duplicate_wsvg_MapOfErrorCorrectedSuddenData;
  allocation_ptrs_[69] = allocate_wsvg_Matrix;
  duplication_ptrs_[69] = duplicate_wsvg_Matrix;
  allocation_ptrs_[70] = allocate_wsvg_Numeric;
  duplication_ptrs_[70] = duplicate_wsvg_Numeric;
  allocation_ptrs_[71] = allocate_wsvg_Ppath;
  duplication_ptrs_[71] = duplicate_wsvg_Ppath;
  allocation_ptrs_[72] = allocate_wsvg_PredefinedModelData;
  duplication_ptrs_[72] = duplicate_wsvg_PredefinedModelData;
  allocation_ptrs_[73] = allocate_wsvg_PropagationMatrix;
  duplication_ptrs_[73] = duplicate_wsvg_PropagationMatrix;
  allocation_ptrs_[74] = allocate_wsvg_QuantumIdentifier;
  duplication_ptrs_[74] = duplicate_wsvg_QuantumIdentifier;
  allocation_ptrs_[75] = allocate_wsvg_RadiationVector;
  duplication_ptrs_[75] = duplicate_wsvg_RadiationVector;
  allocation_ptrs_[76] = allocate_wsvg_Rational;
  duplication_ptrs_[76] = duplicate_wsvg_Rational;
  allocation_ptrs_[77] = allocate_wsvg_ScatteringMetaData;
  duplication_ptrs_[77] = duplicate_wsvg_ScatteringMetaData;
  allocation_ptrs_[78] = allocate_wsvg_SingleScatteringData;
  duplication_ptrs_[78] = duplicate_wsvg_SingleScatteringData;
  allocation_ptrs_[79] = allocate_wsvg_Sparse;
  duplication_ptrs_[79] = duplicate_wsvg_Sparse;
  allocation_ptrs_[80] = allocate_wsvg_SpeciesIsotopologueRatios;
  duplication_ptrs_[80] = duplicate_wsvg_SpeciesIsotopologueRatios;
  allocation_ptrs_[81] = allocate_wsvg_StokesVector;
  duplication_ptrs_[81] = duplicate_wsvg_StokesVector;
  allocation_ptrs_[82] = allocate_wsvg_String;
  duplication_ptrs_[82] = duplicate_wsvg_String;
  allocation_ptrs_[83] = allocate_wsvg_TelsemAtlas;
  duplication_ptrs_[83] = duplicate_wsvg_TelsemAtlas;
  allocation_ptrs_[84] = allocate_wsvg_Tensor3;
  duplication_ptrs_[84] = duplicate_wsvg_Tensor3;
  allocation_ptrs_[85] = allocate_wsvg_Tensor4;
  duplication_ptrs_[85] = duplicate_wsvg_Tensor4;
  allocation_ptrs_[86] = allocate_wsvg_Tensor5;
  duplication_ptrs_[86] = duplicate_wsvg_Tensor5;
  allocation_ptrs_[87] = allocate_wsvg_Tensor6;
  duplication_ptrs_[87] = duplicate_wsvg_Tensor6;
  allocation_ptrs_[88] = allocate_wsvg_Tensor7;
  duplication_ptrs_[88] = duplicate_wsvg_Tensor7;
  allocation_ptrs_[89] = allocate_wsvg_TessemNN;
  duplication_ptrs_[89] = duplicate_wsvg_TessemNN;
  allocation_ptrs_[90] = allocate_wsvg_Time;
  duplication_ptrs_[90] = duplicate_wsvg_Time;
  allocation_ptrs_[91] = allocate_wsvg_Timer;
  duplication_ptrs_[91] = duplicate_wsvg_Timer;
  allocation_ptrs_[92] = allocate_wsvg_TransmissionMatrix;
  duplication_ptrs_[92] = duplicate_wsvg_TransmissionMatrix;
  allocation_ptrs_[93] = allocate_wsvg_Vector;
  duplication_ptrs_[93] = duplicate_wsvg_Vector;
  allocation_ptrs_[94] = allocate_wsvg_Verbosity;
  duplication_ptrs_[94] = duplicate_wsvg_Verbosity;
}