#ifndef _UAL_CLASSES
#define _UAL_CLASSES
#include "UALDef.h"
#include <blitz/array.h> 
using namespace blitz;
namespace ItmNs {

typedef struct {
	char **parameters;
	char **default_param;
	char **schema;
} codeparam_t;

class Itm
{
    private:
    int expIdx;
    int shot, run, refShot, refRun;
    string treeName;
    bool connected;
    
    public:
    Itm();
    Itm(int shot, int run, int refShot, int refRun);
    Itm(int idx);
    void setShot(int inShot) {shot = inShot;}
    void setRun(int inRun) {run = inRun;}
    void setRefShot(int inRefShot){refShot = inRefShot;}
    void setRefNum(int inRefRun){refRun = inRefRun;}
    void setTreeName(char *inTreeName){treeName = inTreeName; }
    void setTreeName(string inTreeName){treeName = inTreeName;}
    int getIdx() {return expIdx;}
    int getShot() {return shot;}
    int getRun() {return run;}
    int getRefShot(){return refShot;}
    int getRefRun(){return refRun;}
    string getTreeName(){return treeName;}
    bool isConnected(){return connected;}
    void open();
    void create();
    void openEnv(char *user, char *tokamak, char *version);
    void createEnv(char *user, char *tokamak, char *version);
    void openHdf5();
    void createHdf5();
    void close();
    void close(char *name, int shot, int run) {close();}
	int getTime(char *path, Array<double,1> &time);
    ~Itm();
    friend ostream &operator << (ostream &os, const Itm &obj);

    #include "CpoDef.h"
    
    
    
          class topinfo:Cpo
          {
          private:
          int expIdx;
          bool connected;
          public:
          
      std::string dataprovider;
    
      std::string description;
    
      std::string firstputdate;
    
      std::string lastupdate;
    
      std::string source;
    
      std::string comment;
    
      std::string dataversion;
    
      std::string workflow;
    
      struct entry {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      } entry;
    
      struct parent_entry {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      } parent_entry;
    
      struct mdinfo {
      
      int shot_min;
    
      int shot_max;
    
      struct md_entry {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      } md_entry;
    
      } mdinfo;
    topinfo();
          void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
          int get();
          int get(int idx);
          int put();
          int put(int idx);
          friend ostream &operator << (ostream &os, const topinfo&obj);

};
      
          class summary:Cpo
          {
          private:
          int expIdx;
          bool connected;
          public:
          
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct ip {
      
      double value;
    
      std::string source;
    
      double time;
    
      } ip;
    
      struct bvac_r {
      
      double value;
    
      std::string source;
    
      double time;
    
      } bvac_r;
    
      struct geom_axis_r {
      
      double value;
    
      std::string source;
    
      double time;
    
      } geom_axis_r;
    
      struct a_minor {
      
      double value;
    
      std::string source;
    
      double time;
    
      } a_minor;
    
      struct elongation {
      
      double value;
    
      std::string source;
    
      double time;
    
      } elongation;
    
      struct tria_lower {
      
      double value;
    
      std::string source;
    
      double time;
    
      } tria_lower;
    
      struct tria_upper {
      
      double value;
    
      std::string source;
    
      double time;
    
      } tria_upper;
    
      struct tev {
      
      double value;
    
      std::string source;
    
      double time;
    
      } tev;
    
      struct tiv {
      
      double value;
    
      std::string source;
    
      double time;
    
      } tiv;
    
      struct nev {
      
      double value;
    
      std::string source;
    
      double time;
    
      } nev;
    
      struct zeffv {
      
      double value;
    
      std::string source;
    
      double time;
    
      } zeffv;
    
      struct beta_pol {
      
      double value;
    
      std::string source;
    
      double time;
    
      } beta_pol;
    
      struct beta_tor {
      
      double value;
    
      std::string source;
    
      double time;
    
      } beta_tor;
    
      struct beta_normal {
      
      double value;
    
      std::string source;
    
      double time;
    
      } beta_normal;
    
      struct li {
      
      double value;
    
      std::string source;
    
      double time;
    
      } li;
    
      struct volume {
      
      double value;
    
      std::string source;
    
      double time;
    
      } volume;
    
      struct area {
      
      double value;
    
      std::string source;
    
      double time;
    
      } area;
    
      struct main_ion1_z {
      
      double value;
    
      std::string source;
    
      double time;
    
      } main_ion1_z;
    
      struct main_ion1_a {
      
      double value;
    
      std::string source;
    
      double time;
    
      } main_ion1_a;
    
      struct main_ion2_z {
      
      double value;
    
      std::string source;
    
      double time;
    
      } main_ion2_z;
    
      struct main_ion2_a {
      
      double value;
    
      std::string source;
    
      double time;
    
      } main_ion2_a;
    
      struct impur1_z {
      
      double value;
    
      std::string source;
    
      double time;
    
      } impur1_z;
    
      struct impur1_a {
      
      double value;
    
      std::string source;
    
      double time;
    
      } impur1_a;
    
      double time;
    summary();
          void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
          int get();
          int get(int idx);
          int put();
          int put(int idx);
          friend ostream &operator << (ostream &os, const summary&obj);

};
      
          class amns:Cpo
          {
          private:
          int expIdx;
          bool connected;
          public:
          
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      std::string version;
    
      std::string source;
    
      int zn;
    
      int zion;
    
      Array<double,1>amn;
    
     Array<std::string,1>state_label;
    
     Array<std::string,1>result_label;
    
     Array<std::string,1>result_unit;
    
     Array<int,1>result_trans;
    
      int bundled;
    
     Array<std::string,1>proc_label;
    
      struct tables {
      
    Array<int,2>id;
    
      struct table_0d {
      
    Array<double,2>table;
    
      } table_0d;
    
      struct table_1d {
      
      struct table_prop {
      
    Array<int,2>coord_extrap;
    
      int interp_type;
    
      std::string coord_label;
    
      std::string coord_unit;
    
      int coord_trans;
    
      int unif_spacing;
    
      } table_prop;
    
      Array<double,1>coord1;
    
    Array<double,3>table;
    
      } table_1d;
    
      struct table_2d {
      
      struct table_prop {
      
     Array<int,3>coord_extrap;
    
     Array<int,1>interp_type;
    
     Array<std::string,1>coord_label;
    
     Array<std::string,1>coord_unit;
    
     Array<int,1>coord_trans;
    
      int unif_spacing;
    
      } table_prop;
    
      Array<double,1>coord1;
    
      Array<double,1>coord2;
    
    Array<double,4>table;
    
      } table_2d;
    
      struct table_3d {
      
      struct table_prop {
      
     Array<int,3>coord_extrap;
    
     Array<int,1>interp_type;
    
     Array<std::string,1>coord_label;
    
     Array<std::string,1>coord_unit;
    
     Array<int,1>coord_trans;
    
      int unif_spacing;
    
      } table_prop;
    
      Array<double,1>coord1;
    
      Array<double,1>coord2;
    
      Array<double,1>coord3;
    
    Array<double,5>table;
    
      } table_3d;
    
      struct table_4d {
      
      struct table_prop {
      
     Array<int,3>coord_extrap;
    
     Array<int,1>interp_type;
    
     Array<std::string,1>coord_label;
    
     Array<std::string,1>coord_unit;
    
     Array<int,1>coord_trans;
    
      int unif_spacing;
    
      } table_prop;
    
      Array<double,1>coord1;
    
      Array<double,1>coord2;
    
      Array<double,1>coord3;
    
      Array<double,1>coord4;
    
    Array<double,6>table;
    
      } table_4d;
    
      struct table_5d {
      
      struct table_prop {
      
     Array<int,3>coord_extrap;
    
     Array<int,1>interp_type;
    
     Array<std::string,1>coord_label;
    
     Array<std::string,1>coord_unit;
    
     Array<int,1>coord_trans;
    
      int unif_spacing;
    
      } table_prop;
    
      Array<double,1>coord1;
    
      Array<double,1>coord2;
    
      Array<double,1>coord3;
    
      Array<double,1>coord4;
    
      Array<double,1>coord5;
    
    Array<double,6>table;
    
      } table_5d;
    
      } tables;
    amns();
          void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
          int get();
          int get(int idx);
          int put();
          int put(int idx);
          friend ostream &operator << (ostream &os, const amns&obj);

};
      
class antennas:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct antenna_ec {
      
     Array<std::string,1>name;
    
      Array<double,1>frequency;
    
      struct power {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } power;
    
     Array<int,1>mode;
    
      struct position {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      Array<double,1>phi;
    
      } position;
    
      struct launchangles {
      
      Array<double,1>alpha;
    
      Array<double,1>beta;
    
      } launchangles;
    
      struct beam {
      
      struct spot {
      
    Array<double,2>waist;
    
      Array<double,1>angle;
    
      } spot;
    
      struct phaseellipse {
      
    Array<double,2>invcurvrad;
    
      Array<double,1>angle;
    
      } phaseellipse;
    
      } beam;
    
      } antenna_ec;
    
      struct antenna_ic {
      
     Array<std::string,1>name;
    
      struct frequency {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } frequency;
    
      struct power {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } power;
    
      struct setup {
      
      struct straps {
      
     Array<int,1>nstraps;
    
      struct phase {
      
    Array<double,2>value;
    
    Array<double,2>abserror;
    
    Array<double,2>relerror;
    
      } phase;
    
    Array<double,2>phi_centre;
    
    Array<double,2>width;
    
    Array<double,2>dist2wall;
    
    Array<int,2>ncoord_strap;
    
      struct coord_strap {
      
    Array<double,3>r;
    
    Array<double,3>z;
    
      } coord_strap;
    
      } straps;
    
      } setup;
    
      } antenna_ic;
    
      struct antenna_lh {
      
     Array<std::string,1>name;
    
      Array<double,1>frequency;
    
      struct power {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } power;
    
      struct position {
      
      struct r {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } r;
    
      struct z {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } z;
    
      struct phi {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } phi;
    
      } position;
    
      struct setup {
      
      struct modules {
      
     Array<int,1>nma_theta;
    
     Array<int,1>nma_phi;
    
      Array<double,1>sm_theta;
    
    Array<double,3>amplitude;
    
    Array<double,3>phase;
    
      struct waveguides {
      
     Array<int,1>nwm_theta;
    
     Array<int,1>nwm_phi;
    
    Array<int,2>mask;
    
     Array<int,1>npwbm_phi;
    
     Array<int,1>npwe_phi;
    
      Array<double,1>sw_theta;
    
      Array<double,1>hw_theta;
    
      Array<double,1>bwa;
    
      Array<double,1>biwp;
    
      Array<double,1>bewp;
    
    Array<double,2>e_phi;
    
    Array<double,2>scl;
    
      } waveguides;
    
      } modules;
    
      } setup;
    
      struct plasmaedge {
      
     Array<int,1>npoints;
    
    Array<double,2>distance;
    
    Array<double,2>density;
    
      } plasmaedge;
    
      struct beam {
      
      struct spot {
      
    Array<double,2>waist;
    
      Array<double,1>angle;
    
      } spot;
    
      struct phaseellipse {
      
    Array<double,2>invcurvrad;
    
      Array<double,1>angle;
    
      } phaseellipse;
    
      } beam;
    
      } antenna_lh;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      double time;
    antennas();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const antennas&obj);
};
class antennasArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    antennasArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <antennas,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    antennas &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class coredelta:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct composition {
      
      Array<double,1>amn;
    
      Array<double,1>zn;
    
      Array<double,1>zion;
    
     Array<int,1>imp_flag;
    
      } composition;
    
      Array<double,1>rho_tor;
    
      Array<double,1>rho_tor_norm;
    
      Array<double,1>delta_psi;
    
      Array<double,1>delta_te;
    
    Array<double,2>delta_ti;
    
    Array<double,3>delta_tz;
    
      Array<double,1>delta_ne;
    
    Array<double,2>delta_ni;
    
    Array<double,3>delta_nz;
    
    Array<double,2>delta_vtor;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      double time;
    coredelta();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const coredelta&obj);
};
class coredeltaArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    coredeltaArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <coredelta,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    coredelta &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class coreneutrals:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      Array<double,1>rho_tor;
    
      Array<double,1>rho_tor_norm;
    
      struct composition {
      
      struct atomlist {
      
      Array<double,1>amn;
    
      Array<double,1>zn;
    
      } atomlist;
    
      struct neutrallist {
      
     Array<int,1>ncomp;
    
    Array<int,2>tatm;
    
    Array<int,2>multatm;
    
      } neutrallist;
    
      struct typelist {
      
     Array<int,1>ntype;
    
    Array<int,2>type;
    
      } typelist;
    
      } composition;
    
      struct profiles {
      
      struct n0 {
      
    Array<double,3>value;
    
    Array<double,3>flux;
    
      struct boundary {
      
    Array<double,3>value;
    
    Array<int,2>type;
    
    Array<int,2>rho_tor;
    
      } boundary;
    
      } n0;
    
      struct t0 {
      
    Array<double,3>value;
    
    Array<double,3>flux;
    
      struct boundary {
      
    Array<double,3>value;
    
    Array<int,2>type;
    
    Array<int,2>rho_tor;
    
      } boundary;
    
      } t0;
    
      struct v0 {
      
      struct toroidal {
      
    Array<double,3>value;
    
      struct boundary {
      
    Array<double,3>value;
    
    Array<int,2>type;
    
    Array<int,2>rho_tor;
    
      } boundary;
    
      } toroidal;
    
      struct poloidal {
      
    Array<double,3>value;
    
      struct boundary {
      
    Array<double,3>value;
    
    Array<int,2>type;
    
    Array<int,2>rho_tor;
    
      } boundary;
    
      } poloidal;
    
      struct radial {
      
    Array<double,3>value;
    
      struct boundary {
      
    Array<double,3>value;
    
    Array<int,2>type;
    
    Array<int,2>rho_tor;
    
      } boundary;
    
      } radial;
    
      } v0;
    
    Array<double,2>prad0;
    
      } profiles;
    
      struct coefficients {
      
      struct recycling {
      
    Array<double,2>particles;
    
    Array<double,2>energy;
    
      } recycling;
    
      struct sputtering {
      
    Array<double,2>physical;
    
    Array<double,2>chemical;
    
      } sputtering;
    
      } coefficients;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      double time;
    coreneutrals();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const coreneutrals&obj);
};
class coreneutralsArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    coreneutralsArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <coreneutrals,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    coreneutrals &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class coreimpur:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      Array<double,1>rho_tor_norm;
    
      Array<double,1>rho_tor;
    
     Array<std::string,1>source;
    
     Array<int,1>flag;
    
      struct desc_impur {
      
      Array<double,1>amn;
    
     Array<int,1>zn;
    
     Array<int,1>i_ion;
    
     Array<int,1>nzimp;
    
    Array<int,2>zmin;
    
    Array<int,2>zmax;
    
      } desc_impur;
    
    Array<double,3>z;
    
    Array<double,3>zsq;
    
    Array<double,3>nz;
    
      struct source_term {
      
    Array<double,3>value;
    
    Array<double,3>integral;
    
     Array<std::string,1>source;
    
      } source_term;
    
      struct boundary {
      
    Array<double,3>value;
    
     Array<std::string,1>source;
    
    Array<int,2>type;
    
    Array<double,2>rho;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      } boundary;
    
      struct transp_coef {
      
    Array<double,3>diff;
    
    Array<double,3>vconv;
    
     Array<std::string,1>source;
    
      } transp_coef;
    
      struct flux {
      
    Array<double,3>flux_dv;
    
    Array<double,3>flux_interp;
    
      } flux;
    
    Array<double,3>time_deriv;
    
     Array<std::string,1>atomic_data;
    
      double time;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    coreimpur();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const coreimpur&obj);
};
class coreimpurArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    coreimpurArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <coreimpur,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    coreimpur &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class coreprof:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      Array<double,1>rho_tor_norm;
    
      Array<double,1>rho_tor;
    
      Array<double,1>drho_dt;
    
      struct toroid_field {
      
      double b0;
    
      double b0prime;
    
      double r0;
    
      double time;
    
      } toroid_field;
    
      struct composition {
      
      Array<double,1>amn;
    
      Array<double,1>zn;
    
      Array<double,1>zion;
    
     Array<int,1>imp_flag;
    
      } composition;
    
      struct psi {
      
      Array<double,1>value;
    
      std::string source;
    
      int flag;
    
      struct boundary {
      
      Array<double,1>value;
    
      std::string source;
    
      int type;
    
      double rho;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      } boundary;
    
      struct jni {
      
      Array<double,1>value;
    
      Array<double,1>integral;
    
      std::string source;
    
      } jni;
    
      struct sigma_par {
      
      Array<double,1>value;
    
      std::string source;
    
      } sigma_par;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      } psi;
    
      struct te {
      
      Array<double,1>value;
    
      std::string source;
    
      int flag;
    
      struct boundary {
      
      Array<double,1>value;
    
      std::string source;
    
      int type;
    
      double rho_tor;
    
      } boundary;
    
      struct source_term {
      
      Array<double,1>value;
    
      Array<double,1>integral;
    
      std::string source;
    
      } source_term;
    
      struct transp_coef {
      
      Array<double,1>diff;
    
      Array<double,1>vconv;
    
      std::string source;
    
      } transp_coef;
    
      struct flux {
      
      Array<double,1>flux_dv;
    
      Array<double,1>flux_interp;
    
      } flux;
    
      Array<double,1>time_deriv;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      } te;
    
      struct ti {
      
    Array<double,2>value;
    
     Array<std::string,1>source;
    
     Array<int,1>flag;
    
      struct boundary {
      
    Array<double,2>value;
    
     Array<std::string,1>source;
    
     Array<int,1>type;
    
      Array<double,1>rho_tor;
    
      } boundary;
    
      struct source_term {
      
    Array<double,2>value;
    
    Array<double,2>integral;
    
     Array<std::string,1>source;
    
      } source_term;
    
      struct transp_coef {
      
    Array<double,2>diff;
    
    Array<double,2>vconv;
    
     Array<std::string,1>source;
    
      } transp_coef;
    
      struct flux {
      
    Array<double,2>flux_dv;
    
    Array<double,2>flux_interp;
    
      } flux;
    
    Array<double,2>time_deriv;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      } ti;
    
      struct ne {
      
      Array<double,1>value;
    
      std::string source;
    
      int flag;
    
      struct boundary {
      
      Array<double,1>value;
    
      std::string source;
    
      int type;
    
      double rho_tor;
    
      } boundary;
    
      struct source_term {
      
      Array<double,1>value;
    
      Array<double,1>integral;
    
      std::string source;
    
      } source_term;
    
      struct transp_coef {
      
      Array<double,1>diff;
    
      Array<double,1>vconv;
    
      std::string source;
    
      } transp_coef;
    
      struct flux {
      
      Array<double,1>flux_dv;
    
      Array<double,1>flux_interp;
    
      } flux;
    
      Array<double,1>time_deriv;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      } ne;
    
      struct ni {
      
    Array<double,2>value;
    
     Array<std::string,1>source;
    
     Array<int,1>flag;
    
      struct boundary {
      
    Array<double,2>value;
    
     Array<std::string,1>source;
    
     Array<int,1>type;
    
      Array<double,1>rho_tor;
    
      } boundary;
    
      struct source_term {
      
    Array<double,2>value;
    
    Array<double,2>integral;
    
     Array<std::string,1>source;
    
      } source_term;
    
      struct transp_coef {
      
    Array<double,2>diff;
    
    Array<double,2>vconv;
    
     Array<std::string,1>source;
    
      } transp_coef;
    
      struct flux {
      
    Array<double,2>flux_dv;
    
    Array<double,2>flux_interp;
    
      } flux;
    
    Array<double,2>time_deriv;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      } ni;
    
      struct vtor {
      
    Array<double,2>value;
    
     Array<std::string,1>source;
    
     Array<int,1>flag;
    
      struct boundary {
      
    Array<double,2>value;
    
     Array<std::string,1>source;
    
     Array<int,1>type;
    
      Array<double,1>rho_tor;
    
      } boundary;
    
      struct source_term {
      
    Array<double,2>value;
    
    Array<double,2>integral;
    
     Array<std::string,1>source;
    
      } source_term;
    
      struct transp_coef {
      
    Array<double,2>diff;
    
    Array<double,2>vconv;
    
     Array<std::string,1>source;
    
      } transp_coef;
    
      struct flux {
      
    Array<double,2>flux_dv;
    
    Array<double,2>flux_interp;
    
      } flux;
    
    Array<double,2>time_deriv;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      } vtor;
    
      struct profiles1d {
      
      struct pe {
      
      Array<double,1>value;
    
      std::string source;
    
      } pe;
    
      struct pi {
      
    Array<double,2>value;
    
     Array<std::string,1>source;
    
      } pi;
    
      struct pr_th {
      
      Array<double,1>value;
    
      std::string source;
    
      } pr_th;
    
      struct pr_perp {
      
      Array<double,1>value;
    
      std::string source;
    
      } pr_perp;
    
      struct pr_parallel {
      
      Array<double,1>value;
    
      std::string source;
    
      } pr_parallel;
    
      struct jtot {
      
      Array<double,1>value;
    
      std::string source;
    
      } jtot;
    
      struct jni {
      
      Array<double,1>value;
    
      std::string source;
    
      } jni;
    
      struct joh {
      
      Array<double,1>value;
    
      std::string source;
    
      } joh;
    
      struct vloop {
      
      Array<double,1>value;
    
      std::string source;
    
      } vloop;
    
      struct sigmapar {
      
      Array<double,1>value;
    
      std::string source;
    
      } sigmapar;
    
      struct qoh {
      
      Array<double,1>value;
    
      std::string source;
    
      } qoh;
    
      struct eparallel {
      
      Array<double,1>value;
    
      std::string source;
    
      } eparallel;
    
      struct e_b {
      
      Array<double,1>value;
    
      std::string source;
    
      } e_b;
    
      struct q {
      
      Array<double,1>value;
    
      std::string source;
    
      } q;
    
      struct shear {
      
      Array<double,1>value;
    
      std::string source;
    
      } shear;
    
      struct ns {
      
    Array<double,2>value;
    
     Array<std::string,1>source;
    
      } ns;
    
      struct mtor {
      
    Array<double,2>value;
    
     Array<std::string,1>source;
    
      } mtor;
    
      struct wtor {
      
    Array<double,2>value;
    
     Array<std::string,1>source;
    
      } wtor;
    
      struct zeff {
      
      Array<double,1>value;
    
      std::string source;
    
      } zeff;
    
      struct bpol {
      
      Array<double,1>value;
    
      std::string source;
    
      } bpol;
    
      struct dpsidt {
      
      Array<double,1>value;
    
      std::string source;
    
      } dpsidt;
    
      struct dpsidt_phi {
      
      Array<double,1>value;
    
      std::string source;
    
      } dpsidt_phi;
    
      struct dvprimedt {
      
      Array<double,1>value;
    
      std::string source;
    
      } dvprimedt;
    
      } profiles1d;
    
      struct globalparam {
      
      double current_tot;
    
      double current_bnd;
    
      double vloop;
    
      double li;
    
      double beta_tor;
    
      double beta_normal;
    
      double beta_pol;
    
      double w_dia;
    
      } globalparam;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      double time;
    coreprof();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const coreprof&obj);
};
class coreprofArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    coreprofArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <coreprof,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    coreprof &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class coresource:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      Array<double,1>rho_tor;
    
      Array<double,1>rho_tor_norm;
    
      struct composition {
      
      Array<double,1>amn;
    
      Array<double,1>zn;
    
      Array<double,1>zion;
    
     Array<int,1>imp_flag;
    
      } composition;
    
      struct toroid_field {
      
      double r0;
    
      double b0;
    
      } toroid_field;
    
      Array<double,1>j;
    
      Array<double,1>sigma;
    
      struct si {
      
    Array<double,2>exp;
    
    Array<double,2>imp;
    
      } si;
    
      struct se {
      
      Array<double,1>exp;
    
      Array<double,1>imp;
    
      } se;
    
      struct sz {
      
    Array<double,3>exp;
    
    Array<double,3>imp;
    
      } sz;
    
      struct qi {
      
    Array<double,2>exp;
    
    Array<double,2>imp;
    
      } qi;
    
      struct qe {
      
      Array<double,1>exp;
    
      Array<double,1>imp;
    
      } qe;
    
      struct qz {
      
    Array<double,3>exp;
    
    Array<double,3>imp;
    
      } qz;
    
      struct ui {
      
    Array<double,2>exp;
    
    Array<double,2>imp;
    
      } ui;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      double time;
    coresource();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const coresource&obj);
};
class coresourceArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    coresourceArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <coresource,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    coresource &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class coretransp:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct composition {
      
      Array<double,1>amn;
    
      Array<double,1>zn;
    
      Array<double,1>zion;
    
     Array<int,1>imp_flag;
    
      } composition;
    
      Array<double,1>rho_tor_norm;
    
      Array<double,1>rho_tor;
    
      Array<double,1>sigma;
    
      struct ni_transp {
      
    Array<double,3>diff_eff;
    
    Array<double,3>vconv_eff;
    
    Array<double,2>flux;
    
      struct off_diagonal {
      
    Array<double,3>d_ni;
    
    Array<double,3>d_ti;
    
    Array<double,2>d_ne;
    
    Array<double,2>d_te;
    
    Array<double,2>d_epar;
    
    Array<double,2>d_mtor;
    
      } off_diagonal;
    
      int flag;
    
      } ni_transp;
    
      struct ne_transp {
      
    Array<double,2>diff_eff;
    
    Array<double,2>vconv_eff;
    
      Array<double,1>flux;
    
      struct off_diagonal {
      
    Array<double,2>d_ni;
    
    Array<double,2>d_ti;
    
      Array<double,1>d_ne;
    
      Array<double,1>d_te;
    
      Array<double,1>d_epar;
    
      Array<double,1>d_mtor;
    
      } off_diagonal;
    
      int flag;
    
      } ne_transp;
    
      struct nz_transp {
      
    Array<double,3>diff_eff;
    
    Array<double,3>vconv_eff;
    
    Array<double,3>exchange;
    
    Array<double,3>flux;
    
      int flag;
    
      } nz_transp;
    
      struct ti_transp {
      
    Array<double,2>diff_eff;
    
    Array<double,2>vconv_eff;
    
    Array<double,2>exchange;
    
    Array<double,2>qgi;
    
    Array<double,2>flux;
    
      struct off_diagonal {
      
    Array<double,3>d_ni;
    
    Array<double,3>d_ti;
    
    Array<double,2>d_ne;
    
    Array<double,2>d_te;
    
    Array<double,2>d_epar;
    
    Array<double,2>d_mtor;
    
      } off_diagonal;
    
      int flag;
    
      } ti_transp;
    
      struct te_transp {
      
      Array<double,1>diff_eff;
    
      Array<double,1>vconv_eff;
    
      Array<double,1>flux;
    
      struct off_diagonal {
      
    Array<double,2>d_ni;
    
    Array<double,2>d_ti;
    
      Array<double,1>d_ne;
    
      Array<double,1>d_te;
    
      Array<double,1>d_epar;
    
      Array<double,1>d_mtor;
    
      } off_diagonal;
    
      int flag;
    
      } te_transp;
    
      struct tz_transp {
      
    Array<double,3>diff_eff;
    
    Array<double,3>vconv_eff;
    
    Array<double,3>exchange;
    
    Array<double,3>flux;
    
      int flag;
    
      } tz_transp;
    
      struct vtor_transp {
      
    Array<double,2>diff_eff;
    
    Array<double,2>vconv_eff;
    
    Array<double,2>flux;
    
      struct off_diagonal {
      
    Array<double,3>d_ni;
    
    Array<double,3>d_ti;
    
    Array<double,2>d_ne;
    
    Array<double,2>d_te;
    
    Array<double,2>d_epar;
    
    Array<double,2>d_mtor;
    
      } off_diagonal;
    
      int flag;
    
      } vtor_transp;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      double time;
    coretransp();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const coretransp&obj);
};
class coretranspArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    coretranspArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <coretransp,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    coretransp &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class cxdiag:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct setup {
      
      struct position {
      
      struct r {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } r;
    
      struct z {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } z;
    
      struct phi {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } phi;
    
      } position;
    
      } setup;
    
      struct measure {
      
      struct ti {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } ti;
    
      struct vtor {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } vtor;
    
      struct vpol {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } vpol;
    
      } measure;
    
      double time;
    cxdiag();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const cxdiag&obj);
};
class cxdiagArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    cxdiagArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <cxdiag,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    cxdiag &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class distribution:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct composition {
      
      Array<double,1>amn;
    
      Array<double,1>zn;
    
      Array<double,1>zion;
    
     Array<int,1>imp_flag;
    
      } composition;
    
     Array<int,1>calc_spec;
    
      struct nucl_reac {
      
     Array<int,1>nreacs;
    
    Array<int,2>point_reac;
    
    Array<int,2>id_reac;
    
      } nucl_reac;
    
      struct global_param {
      
      Array<double,1>enrg;
    
      Array<double,1>enrg_para;
    
    Array<double,2>pow_coll_i;
    
      Array<double,1>pow_coll_e;
    
      struct therm_src {
      
      Array<double,1>particles;
    
      Array<double,1>power;
    
      Array<double,1>torque;
    
      } therm_src;
    
      struct losses {
      
      struct orb_loss {
      
      Array<double,1>particles;
    
      Array<double,1>power;
    
      Array<double,1>torque;
    
      } orb_loss;
    
      struct neutr_loss {
      
      Array<double,1>particles;
    
      Array<double,1>power;
    
      Array<double,1>torque;
    
      } neutr_loss;
    
      } losses;
    
      Array<double,1>cur_dr_tor;
    
    Array<double,2>trq_i;
    
      Array<double,1>trq_e;
    
      Array<double,1>trq_j_rxb;
    
      struct nucl_reac_th {
      
    Array<double,2>rate;
    
    Array<double,2>power;
    
      } nucl_reac_th;
    
      struct nucl_reac_sf {
      
      Array<double,1>rate;
    
      Array<double,1>power;
    
      } nucl_reac_sf;
    
      } global_param;
    
      struct profiles_1d {
      
     Array<int,1>npsi;
    
    Array<double,2>rho_tor_norm;
    
    Array<double,2>rho_tor;
    
    Array<double,2>psi;
    
    Array<double,2>enrgd_tot;
    
    Array<double,2>enrgd_para;
    
    Array<double,3>powd_coll_i;
    
    Array<double,2>powd_coll_e;
    
      struct therm_srcd {
      
    Array<double,2>particlesd;
    
    Array<double,2>powerd;
    
    Array<double,2>torqued;
    
      } therm_srcd;
    
      struct lossesd {
      
      struct orb_loss {
      
    Array<double,2>particlesd;
    
    Array<double,2>powerd;
    
    Array<double,2>torqued;
    
      } orb_loss;
    
      struct neutr_loss {
      
    Array<double,2>particlesd;
    
    Array<double,2>powerd;
    
    Array<double,2>torqued;
    
      } neutr_loss;
    
      } lossesd;
    
    Array<double,2>curd_fp;
    
      Array<double,1>curd_dr;
    
    Array<double,3>trqd_i;
    
    Array<double,2>trqd_e;
    
    Array<double,2>trqd_jrxb;
    
      struct nucl_rd_th {
      
    Array<double,3>rated;
    
    Array<double,3>powerd;
    
      } nucl_rd_th;
    
      struct nucl_rd_sf {
      
    Array<double,2>rate;
    
    Array<double,2>power;
    
      } nucl_rd_sf;
    
    Array<double,2>enrg_tot;
    
    Array<double,2>enrg_para;
    
    Array<double,3>pow_coll_i;
    
    Array<double,2>pow_coll_e;
    
      struct therm_src {
      
    Array<double,2>particles;
    
    Array<double,2>power;
    
    Array<double,2>torque;
    
      } therm_src;
    
      struct losses {
      
      struct orb_loss {
      
    Array<double,2>particles;
    
    Array<double,2>power;
    
    Array<double,2>torque;
    
      } orb_loss;
    
      struct neutr_loss {
      
    Array<double,2>particles;
    
    Array<double,2>power;
    
    Array<double,2>torque;
    
      } neutr_loss;
    
      } losses;
    
    Array<double,2>cur_fp;
    
    Array<double,2>cur_dr;
    
    Array<double,3>trq_i;
    
    Array<double,2>trq_e;
    
    Array<double,2>trq_j_rxb;
    
      struct nucl_reac_th {
      
    Array<double,3>rate;
    
    Array<double,3>power;
    
      } nucl_reac_th;
    
      struct nucl_reac_sf {
      
    Array<double,2>rate;
    
    Array<double,2>power;
    
      } nucl_reac_sf;
    
      } profiles_1d;
    
      struct dist_func {
      
     Array<int,1>sol_type;
    
      struct test_part {
      
      Array<double,1>nvar;
    
    Array<int,2>var_id;
    
    Array<double,2>var1;
    
    Array<double,2>var2;
    
    Array<double,2>var3;
    
    Array<double,2>var4;
    
    Array<double,2>var5;
    
    Array<double,2>var6;
    
    Array<double,2>weight;
    
      } test_part;
    
      struct f0 {
      
     Array<int,1>grid_type;
    
      struct grid {
      
    Array<double,2>dim1;
    
     Array<int,1>ndim1;
    
    Array<double,2>dim2;
    
     Array<int,1>ndim2;
    
    Array<double,2>dim3;
    
     Array<int,1>ndim3;
    
    Array<double,4>jacobian;
    
      } grid;
    
    Array<double,4>value;
    
      } f0;
    
      struct fullf {
      
     Array<int,1>grid_type;
    
      struct grid {
      
    Array<double,2>dim1;
    
     Array<int,1>ndim1;
    
    Array<double,2>dim2;
    
     Array<int,1>ndim2;
    
    Array<double,2>dim3;
    
     Array<int,1>ndim3;
    
    Array<double,4>jacobian;
    
      } grid;
    
    Array<double,4>value;
    
      } fullf;
    
      } dist_func;
    
      struct input_src {
      
      struct particle_src {
      
      struct total {
      
      Array<double,1>particles;
    
      Array<double,1>power;
    
      Array<double,1>torque;
    
      } total;
    
      struct volume_intgr {
      
    Array<double,2>particles;
    
    Array<double,2>power;
    
    Array<double,2>torque;
    
      } volume_intgr;
    
      struct flux_surf_av {
      
    Array<double,2>particlesd;
    
    Array<double,2>powerd;
    
    Array<double,2>torqued;
    
      } flux_surf_av;
    
      } particle_src;
    
      struct wave_src {
      
     Array<std::string,1>type;
    
      Array<double,1>wave_power;
    
    Array<double,2>wave_powerd;
    
      } wave_src;
    
      } input_src;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      double time;
    distribution();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const distribution&obj);
};
class distributionArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    distributionArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <distribution,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    distribution &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class distsource:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct composition {
      
      Array<double,1>amn;
    
      Array<double,1>zn;
    
      Array<double,1>zion;
    
     Array<int,1>imp_flag;
    
      } composition;
    
     Array<int,1>src_spec;
    
      struct global_param {
      
      Array<double,1>src_pow;
    
      Array<double,1>src_rate;
    
      } global_param;
    
      struct profiles_1d {
      
     Array<int,1>npsi;
    
    Array<double,2>rho_tor_norm;
    
    Array<double,2>rho_tor;
    
    Array<double,2>psi;
    
    Array<double,2>pow_den;
    
    Array<double,2>src_rate;
    
      } profiles_1d;
    
      struct source_4d {
      
     Array<int,1>gyrosrc_type;
    
     Array<int,1>grid_type;
    
      struct rect_grid {
      
     Array<int,1>ndim1;
    
     Array<int,1>ndim2;
    
     Array<int,1>ndim3;
    
     Array<int,1>ndim4;
    
    Array<double,2>dim1;
    
    Array<double,2>dim2;
    
    Array<double,2>dim3;
    
    Array<double,2>dim4;
    
    Array<double,5>jacobian;
    
      } rect_grid;
    
    Array<double,5>source;
    
      } source_4d;
    
      struct source_tp {
      
     Array<int,1>n_particles;
    
      int var_type;
    
    Array<double,2>var1;
    
    Array<double,2>var2;
    
    Array<double,2>var3;
    
    Array<double,2>var4;
    
    Array<double,2>var5;
    
    Array<double,2>var6;
    
    Array<double,2>weight;
    
      } source_tp;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      double time;
    distsource();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const distsource&obj);
};
class distsourceArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    distsourceArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <distsource,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    distsource &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class ecediag:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct setup {
      
      Array<double,1>frequency;
    
      struct position {
      
      struct r {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } r;
    
      struct z {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } z;
    
      struct phi {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } phi;
    
      } position;
    
      } setup;
    
      struct measure {
      
      struct te {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } te;
    
      } measure;
    
      double time;
    ecediag();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const ecediag&obj);
};
class ecediagArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    ecediagArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <ecediag,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    ecediag &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class edge:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct grid {
      
      struct spaces {
      
      int nspace;
    
      struct space_1 {
      
     Array<int,1>type_coord;
    
    Array<double,2>node_value;
    
      struct alter_coord {
      
     Array<int,1>type_coord;
    
    Array<double,2>node_value;
    
      } alter_coord;
    
     Array<int,1>nobject;
    
     Array<int,1>nobject_bou;
    
      int neighborside;
    
    Array<int,2>neighbors;
    
     Array<int,1>OBJDEF;
    
      struct properties {
      
     Array<int,1>alias;
    
     Array<int,1>type;
    
     Array<int,1>is_x;
    
      std::string node_connect;
    
      struct bezier {
      
    Array<double,2>u;
    
    Array<double,2>v;
    
    Array<double,2>w;
    
      } bezier;
    
      } properties;
    
      } space_1;
    
      struct space_2 {
      
     Array<int,1>type_coord;
    
    Array<double,2>node_value;
    
      struct alter_coord {
      
     Array<int,1>type_coord;
    
    Array<double,2>node_value;
    
      } alter_coord;
    
     Array<int,1>nobject;
    
     Array<int,1>nobject_bou;
    
      int neighborside;
    
    Array<int,2>neighbors;
    
     Array<int,1>OBJDEF;
    
      struct properties {
      
     Array<int,1>alias;
    
     Array<int,1>type;
    
     Array<int,1>is_x;
    
      std::string node_connect;
    
      struct bezier {
      
    Array<double,2>u;
    
    Array<double,2>v;
    
    Array<double,2>w;
    
      } bezier;
    
      } properties;
    
      } space_2;
    
      struct space_3 {
      
     Array<int,1>type_coord;
    
    Array<double,2>node_value;
    
      struct alter_coord {
      
     Array<int,1>type_coord;
    
    Array<double,2>node_value;
    
      } alter_coord;
    
     Array<int,1>nobject;
    
     Array<int,1>nobject_bou;
    
      int neighborside;
    
    Array<int,2>neighbors;
    
     Array<int,1>OBJDEF;
    
      struct properties {
      
     Array<int,1>alias;
    
     Array<int,1>type;
    
     Array<int,1>is_x;
    
      std::string node_connect;
    
      struct bezier {
      
    Array<double,2>u;
    
    Array<double,2>v;
    
    Array<double,2>w;
    
      } bezier;
    
      } properties;
    
      } space_3;
    
      struct space_4 {
      
     Array<int,1>type_coord;
    
    Array<double,2>node_value;
    
      struct alter_coord {
      
     Array<int,1>type_coord;
    
    Array<double,2>node_value;
    
      } alter_coord;
    
     Array<int,1>nobject;
    
     Array<int,1>nobject_bou;
    
      int neighborside;
    
    Array<int,2>neighbors;
    
     Array<int,1>OBJDEF;
    
      struct properties {
      
     Array<int,1>alias;
    
     Array<int,1>type;
    
     Array<int,1>is_x;
    
      std::string node_connect;
    
      struct bezier {
      
    Array<double,2>u;
    
    Array<double,2>v;
    
    Array<double,2>w;
    
      } bezier;
    
      } properties;
    
      } space_4;
    
      struct space_5 {
      
     Array<int,1>type_coord;
    
    Array<double,2>node_value;
    
      struct alter_coord {
      
     Array<int,1>type_coord;
    
    Array<double,2>node_value;
    
      } alter_coord;
    
     Array<int,1>nobject;
    
     Array<int,1>nobject_bou;
    
      int neighborside;
    
    Array<int,2>neighbors;
    
     Array<int,1>OBJDEF;
    
      struct properties {
      
     Array<int,1>alias;
    
     Array<int,1>type;
    
     Array<int,1>is_x;
    
      std::string node_connect;
    
      struct bezier {
      
    Array<double,2>u;
    
    Array<double,2>v;
    
    Array<double,2>w;
    
      } bezier;
    
      } properties;
    
      } space_5;
    
      } spaces;
    
      Array<double,1>metric;
    
      } grid;
    
    Array<double,2>te;
    
    Array<double,2>ne;
    
      double time;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    edge();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const edge&obj);
};
class edgeArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    edgeArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <edge,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    edge &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class equilibrium:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct eqconstraint {
      
      struct bpol {
      
      Array<double,1>measured;
    
      std::string source;
    
      double time;
    
     Array<int,1>exact;
    
      Array<double,1>weight;
    
      Array<double,1>sigma;
    
      Array<double,1>calculated;
    
      Array<double,1>chi2;
    
      } bpol;
    
      struct bvac_r {
      
      double measured;
    
      std::string source;
    
      double time;
    
      int exact;
    
      double weight;
    
      double sigma;
    
      double calculated;
    
      double chi2;
    
      } bvac_r;
    
      struct faraday {
      
      Array<double,1>measured;
    
      std::string source;
    
      double time;
    
     Array<int,1>exact;
    
      Array<double,1>weight;
    
      Array<double,1>sigma;
    
      Array<double,1>calculated;
    
      Array<double,1>chi2;
    
      } faraday;
    
      struct flux {
      
      Array<double,1>measured;
    
      std::string source;
    
      double time;
    
     Array<int,1>exact;
    
      Array<double,1>weight;
    
      Array<double,1>sigma;
    
      Array<double,1>calculated;
    
      Array<double,1>chi2;
    
      } flux;
    
      struct i_plasma {
      
      double measured;
    
      std::string source;
    
      double time;
    
      int exact;
    
      double weight;
    
      double sigma;
    
      double calculated;
    
      double chi2;
    
      } i_plasma;
    
      struct isoflux {
      
      struct position {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      } position;
    
      std::string source;
    
      Array<double,1>weight;
    
      Array<double,1>sigma;
    
      Array<double,1>calculated;
    
      Array<double,1>chi2;
    
      } isoflux;
    
      struct jsurf {
      
      Array<double,1>measured;
    
      std::string source;
    
      double time;
    
     Array<int,1>exact;
    
      Array<double,1>weight;
    
      Array<double,1>sigma;
    
      Array<double,1>calculated;
    
      Array<double,1>chi2;
    
      } jsurf;
    
      struct magnet_iron {
      
      struct mr {
      
      Array<double,1>measured;
    
      std::string source;
    
      double time;
    
     Array<int,1>exact;
    
      Array<double,1>weight;
    
      Array<double,1>sigma;
    
      Array<double,1>calculated;
    
      Array<double,1>chi2;
    
      } mr;
    
      struct mz {
      
      Array<double,1>measured;
    
      std::string source;
    
      double time;
    
     Array<int,1>exact;
    
      Array<double,1>weight;
    
      Array<double,1>sigma;
    
      Array<double,1>calculated;
    
      Array<double,1>chi2;
    
      } mz;
    
      } magnet_iron;
    
      struct mse {
      
      Array<double,1>measured;
    
      std::string source;
    
      double time;
    
     Array<int,1>exact;
    
      Array<double,1>weight;
    
      Array<double,1>sigma;
    
      Array<double,1>calculated;
    
      Array<double,1>chi2;
    
      } mse;
    
      struct ne {
      
      Array<double,1>measured;
    
      std::string source;
    
      double time;
    
     Array<int,1>exact;
    
      Array<double,1>weight;
    
      Array<double,1>sigma;
    
      Array<double,1>calculated;
    
      Array<double,1>chi2;
    
      } ne;
    
      struct pfcurrent {
      
      Array<double,1>measured;
    
      std::string source;
    
      double time;
    
     Array<int,1>exact;
    
      Array<double,1>weight;
    
      Array<double,1>sigma;
    
      Array<double,1>calculated;
    
      Array<double,1>chi2;
    
      } pfcurrent;
    
      struct pressure {
      
      Array<double,1>measured;
    
      std::string source;
    
      double time;
    
     Array<int,1>exact;
    
      Array<double,1>weight;
    
      Array<double,1>sigma;
    
      Array<double,1>calculated;
    
      Array<double,1>chi2;
    
      } pressure;
    
      struct q {
      
      Array<double,1>qvalue;
    
      struct position {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      } position;
    
      std::string source;
    
      int exact;
    
      Array<double,1>weight;
    
      Array<double,1>sigma;
    
      Array<double,1>calculated;
    
      Array<double,1>chi2;
    
      } q;
    
      struct xpts {
      
      struct position {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      } position;
    
      std::string source;
    
      Array<double,1>weight;
    
      Array<double,1>sigma;
    
      Array<double,1>calculated;
    
      Array<double,1>chi2;
    
      } xpts;
    
      } eqconstraint;
    
      struct eqgeometry {
      
      std::string source;
    
      int boundarytype;
    
      struct boundary {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      int npoints;
    
      } boundary;
    
      struct geom_axis {
      
      double r;
    
      double z;
    
      } geom_axis;
    
      double a_minor;
    
      double elongation;
    
      double tria_upper;
    
      double tria_lower;
    
      struct xpts {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      } xpts;
    
      struct left_low_st {
      
      double r;
    
      double z;
    
      } left_low_st;
    
      struct right_low_st {
      
      double r;
    
      double z;
    
      } right_low_st;
    
      struct left_up_st {
      
      double r;
    
      double z;
    
      } left_up_st;
    
      struct right_up_st {
      
      double r;
    
      double z;
    
      } right_up_st;
    
      struct active_limit {
      
      double r;
    
      double z;
    
      } active_limit;
    
      } eqgeometry;
    
      struct flush {
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct position {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      } position;
    
    Array<double,2>coef;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      } flush;
    
      struct global_param {
      
      double beta_pol;
    
      double beta_tor;
    
      double beta_normal;
    
      double i_plasma;
    
      double li;
    
      double volume;
    
      double area;
    
      double psi_ax;
    
      double psi_bound;
    
      struct mag_axis {
      
      struct position {
      
      double r;
    
      double z;
    
      } position;
    
      double bphi;
    
      double q;
    
      } mag_axis;
    
      double q_95;
    
      double q_min;
    
      struct toroid_field {
      
      double r0;
    
      double b0;
    
      } toroid_field;
    
      double w_mhd;
    
      } global_param;
    
      struct profiles_1d {
      
      Array<double,1>psi;
    
      Array<double,1>phi;
    
      Array<double,1>pressure;
    
      Array<double,1>F_dia;
    
      Array<double,1>pprime;
    
      Array<double,1>ffprime;
    
      Array<double,1>jphi;
    
      Array<double,1>jparallel;
    
      Array<double,1>q;
    
      Array<double,1>r_inboard;
    
      Array<double,1>r_outboard;
    
      Array<double,1>rho_tor;
    
      Array<double,1>rho_vol;
    
      Array<double,1>beta_pol;
    
      Array<double,1>li;
    
      Array<double,1>elongation;
    
      Array<double,1>tria_upper;
    
      Array<double,1>tria_lower;
    
      Array<double,1>volume;
    
      Array<double,1>vprime;
    
      Array<double,1>area;
    
      Array<double,1>aprime;
    
      Array<double,1>surface;
    
      Array<double,1>ftrap;
    
      Array<double,1>gm1;
    
      Array<double,1>gm2;
    
      Array<double,1>gm3;
    
      Array<double,1>gm4;
    
      Array<double,1>gm5;
    
      Array<double,1>gm6;
    
      Array<double,1>gm7;
    
      Array<double,1>gm8;
    
      Array<double,1>gm9;
    
      } profiles_1d;
    
      struct profiles_2d {
      
      std::string grid_type;
    
      struct grid {
      
      Array<double,1>dim1;
    
      Array<double,1>dim2;
    
    Array<int,2>connect;
    
      } grid;
    
    Array<double,2>psi_grid;
    
    Array<double,2>jphi_grid;
    
    Array<double,2>jpar_grid;
    
    Array<double,2>br;
    
    Array<double,2>bz;
    
    Array<double,2>bphi;
    
      struct position {
      
    Array<double,2>r;
    
    Array<double,2>z;
    
      } position;
    
      } profiles_2d;
    
      struct coord_sys {
      
      std::string grid_type;
    
      struct grid {
      
      Array<double,1>dim1;
    
      Array<double,1>dim2;
    
      } grid;
    
    Array<double,2>jacobian;
    
    Array<double,2>g_11;
    
    Array<double,2>g_12;
    
    Array<double,2>g_13;
    
    Array<double,2>g_22;
    
    Array<double,2>g_23;
    
    Array<double,2>g_33;
    
      struct position {
      
    Array<double,2>r;
    
    Array<double,2>z;
    
      } position;
    
      } coord_sys;
    
      double time;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    equilibrium();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const equilibrium&obj);
};
class equilibriumArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    equilibriumArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <equilibrium,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    equilibrium &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class interfdiag:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      std::string expression;
    
      struct setup_line {
      
      struct pivot_point {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      Array<double,1>phi;
    
      } pivot_point;
    
      Array<double,1>horchordang1;
    
      Array<double,1>verchordang1;
    
      Array<double,1>width;
    
      struct second_point {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      Array<double,1>phi;
    
      } second_point;
    
      Array<double,1>horchordang2;
    
      Array<double,1>verchordang2;
    
      struct third_point {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      Array<double,1>phi;
    
      } third_point;
    
      int nchordpoints;
    
      } setup_line;
    
      struct measure {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } measure;
    
      double time;
    interfdiag();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const interfdiag&obj);
};
class interfdiagArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    interfdiagArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <interfdiag,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    interfdiag &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class ironmodel:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct desc_iron {
      
     Array<std::string,1>name;
    
     Array<std::string,1>id;
    
      struct permeability {
      
    Array<double,2>b;
    
    Array<double,2>mur;
    
      } permeability;
    
      struct geom_iron {
      
     Array<int,1>npoints;
    
      struct rzcoordinate {
      
    Array<double,2>r;
    
    Array<double,2>z;
    
      } rzcoordinate;
    
      } geom_iron;
    
      } desc_iron;
    
      struct magnetise {
      
      struct mr {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } mr;
    
      struct mz {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } mz;
    
      } magnetise;
    
      double time;
    ironmodel();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const ironmodel&obj);
};
class ironmodelArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    ironmodelArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <ironmodel,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    ironmodel &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class launchs:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
     Array<std::string,1>name;
    
     Array<std::string,1>type;
    
      Array<double,1>frequency;
    
     Array<int,1>mode;
    
      struct position {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      Array<double,1>phi;
    
      } position;
    
      struct spectrum {
      
     Array<int,1>nn_phi;
    
     Array<int,1>nn_theta;
    
    Array<double,2>n_phi;
    
    Array<double,2>n_theta;
    
    Array<double,3>power;
    
      } spectrum;
    
      struct beam {
      
      struct spot {
      
    Array<double,2>waist;
    
      Array<double,1>angle;
    
      } spot;
    
      struct phaseellipse {
      
    Array<double,2>invcurvrad;
    
      Array<double,1>angle;
    
      } phaseellipse;
    
      } beam;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      double time;
    launchs();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const launchs&obj);
};
class launchsArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    launchsArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <launchs,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    launchs &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
          class limiter:Cpo
          {
          private:
          int expIdx;
          bool connected;
          public:
          
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct position {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      } position;
    limiter();
          void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
          int get();
          int get(int idx);
          int put();
          int put(int idx);
          friend ostream &operator << (ostream &os, const limiter&obj);

};
      
class mhd:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
     Array<int,1>n;
    
    Array<int,2>m;
    
      Array<double,1>psi;
    
      Array<double,1>frequency;
    
      Array<double,1>growthrate;
    
    Array<double,3>disp_perp;
    
    Array<double,3>disp_par;
    
      Array<double,1>tau_alfven;
    
      Array<double,1>tau_resistive;
    
      double time;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    mhd();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const mhd&obj);
};
class mhdArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    mhdArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <mhd,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    mhd &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class magdiag:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct ip {
      
      double value;
    
      double abserror;
    
      double relerror;
    
      } ip;
    
      struct diamagflux {
      
      double value;
    
      double abserror;
    
      double relerror;
    
      } diamagflux;
    
      struct flux_loops {
      
      struct setup_floops {
      
     Array<std::string,1>name;
    
     Array<std::string,1>id;
    
      struct position {
      
    Array<double,2>r;
    
    Array<double,2>z;
    
    Array<double,2>phi;
    
      } position;
    
     Array<int,1>npoints;
    
      } setup_floops;
    
      struct measure {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } measure;
    
      } flux_loops;
    
      struct bpol_probes {
      
      struct setup_bprobe {
      
     Array<std::string,1>name;
    
     Array<std::string,1>id;
    
      struct position {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      } position;
    
      Array<double,1>polangle;
    
      Array<double,1>torangle;
    
      Array<double,1>area;
    
      Array<double,1>length;
    
     Array<int,1>turns;
    
      } setup_bprobe;
    
      struct measure {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } measure;
    
      } bpol_probes;
    
      double time;
    magdiag();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const magdiag&obj);
};
class magdiagArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    magdiagArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <magdiag,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    magdiag &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class msediag:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct setup_mse {
      
      struct rzgamma {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      Array<double,1>phi;
    
      Array<double,1>dr;
    
      Array<double,1>dz;
    
      Array<double,1>dphi;
    
      } rzgamma;
    
    Array<double,2>geom_coef;
    
      } setup_mse;
    
      struct measure {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } measure;
    
      double time;
    msediag();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const msediag&obj);
};
class msediagArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    msediagArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <msediag,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    msediag &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class nbi:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct composition {
      
      Array<double,1>amn;
    
      Array<double,1>zn;
    
      Array<double,1>zion;
    
     Array<int,1>imp_flag;
    
      } composition;
    
     Array<int,1>inj_spec;
    
     Array<int,1>nunits_spec;
    
    Array<int,2>spec2unit;
    
     Array<int,1>unit2spec;
    
      struct pow_unit {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } pow_unit;
    
      struct inj_eng_unit {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } inj_eng_unit;
    
      struct halfe_cfr {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } halfe_cfr;
    
      struct thirde_cfr {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } thirde_cfr;
    
      struct setup_inject {
      
      struct position {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      Array<double,1>phi;
    
      } position;
    
      Array<double,1>tang_rad;
    
      Array<double,1>angle;
    
     Array<int,1>direction;
    
      Array<double,1>div_vert;
    
      Array<double,1>div_horiz;
    
      Array<double,1>focal_len_hz;
    
      Array<double,1>focal_len_vc;
    
      struct beamlets {
      
     Array<int,1>nbeamlets;
    
      struct position {
      
    Array<double,2>r;
    
    Array<double,2>z;
    
    Array<double,2>phi;
    
      } position;
    
    Array<double,2>tang_rad_blt;
    
    Array<double,2>angle_blt;
    
    Array<double,2>pow_frc_blt;
    
      } beamlets;
    
      } setup_inject;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      double time;
    nbi();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const nbi&obj);
};
class nbiArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    nbiArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <nbi,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    nbi &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class neoclassic:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      Array<double,1>rho_tor_norm;
    
      Array<double,1>rho_tor;
    
      struct composition {
      
      Array<double,1>amn;
    
      Array<double,1>zn;
    
      Array<double,1>zion;
    
     Array<int,1>imp_flag;
    
      } composition;
    
      struct ni_neo {
      
    Array<double,2>diff_eff;
    
    Array<double,2>vconv_eff;
    
    Array<double,2>exchange;
    
    Array<double,2>qgi;
    
    Array<double,2>flux;
    
      struct off_diagonal {
      
    Array<double,3>d_ni;
    
    Array<double,3>d_ti;
    
    Array<double,2>d_ne;
    
    Array<double,2>d_te;
    
    Array<double,2>d_epar;
    
    Array<double,2>d_mtor;
    
      } off_diagonal;
    
      int flag;
    
      } ni_neo;
    
      struct ne_neo {
      
      Array<double,1>diff_eff;
    
      Array<double,1>vconv_eff;
    
      Array<double,1>flux;
    
      struct off_diagonal {
      
    Array<double,2>d_ni;
    
    Array<double,2>d_ti;
    
      Array<double,1>d_ne;
    
      Array<double,1>d_te;
    
      Array<double,1>d_epar;
    
      Array<double,1>d_mtor;
    
      } off_diagonal;
    
      int flag;
    
      } ne_neo;
    
      struct nz_neo {
      
    Array<double,3>diff_eff;
    
    Array<double,3>vconv_eff;
    
    Array<double,3>exchange;
    
    Array<double,3>flux;
    
      int flag;
    
      } nz_neo;
    
      struct ti_neo {
      
    Array<double,2>diff_eff;
    
    Array<double,2>vconv_eff;
    
    Array<double,2>exchange;
    
    Array<double,2>qgi;
    
    Array<double,2>flux;
    
      struct off_diagonal {
      
    Array<double,3>d_ni;
    
    Array<double,3>d_ti;
    
    Array<double,2>d_ne;
    
    Array<double,2>d_te;
    
    Array<double,2>d_epar;
    
    Array<double,2>d_mtor;
    
      } off_diagonal;
    
      int flag;
    
      } ti_neo;
    
      struct te_neo {
      
      Array<double,1>diff_eff;
    
      Array<double,1>vconv_eff;
    
      Array<double,1>flux;
    
      struct off_diagonal {
      
    Array<double,2>d_ni;
    
    Array<double,2>d_ti;
    
      Array<double,1>d_ne;
    
      Array<double,1>d_te;
    
      Array<double,1>d_epar;
    
      Array<double,1>d_mtor;
    
      } off_diagonal;
    
      int flag;
    
      } te_neo;
    
      struct tz_neo {
      
    Array<double,3>diff_eff;
    
    Array<double,3>vconv_eff;
    
    Array<double,3>exchange;
    
    Array<double,3>flux;
    
      int flag;
    
      } tz_neo;
    
      struct mtor_neo {
      
      Array<double,1>diff_eff;
    
      Array<double,1>vconv_eff;
    
      Array<double,1>flux;
    
      struct off_diagonal {
      
    Array<double,2>d_ni;
    
    Array<double,2>d_ti;
    
      Array<double,1>d_ne;
    
      Array<double,1>d_te;
    
      Array<double,1>d_epar;
    
      Array<double,1>d_mtor;
    
      } off_diagonal;
    
      int flag;
    
      } mtor_neo;
    
      Array<double,1>sigma;
    
      Array<double,1>jboot;
    
      Array<double,1>er;
    
    Array<double,2>vpol;
    
    Array<double,3>fext;
    
      Array<double,1>jext;
    
      double time;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    neoclassic();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const neoclassic&obj);
};
class neoclassicArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    neoclassicArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <neoclassic,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    neoclassic &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class orbit:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct orbitt_id {
      
      double amn;
    
      double zion;
    
      Array<double,1>energy;
    
      Array<double,1>magn_mom;
    
      Array<double,1>p_phi;
    
     Array<int,1>sigma;
    
      } orbitt_id;
    
      struct orb_trace {
      
    Array<double,2>time_orb;
    
     Array<int,1>ntorb;
    
    Array<double,2>r;
    
    Array<double,2>z;
    
    Array<double,2>psi;
    
    Array<double,2>theta_b;
    
    Array<double,2>v_parallel;
    
    Array<double,2>v_perp;
    
      } orb_trace;
    
      struct orb_glob_dat {
      
     Array<int,1>orbit_type;
    
      Array<double,1>omega_b;
    
      Array<double,1>omega_phi;
    
      Array<double,1>omega_c_av;
    
      struct special_pos {
      
      struct midplane {
      
      struct outer {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      Array<double,1>psi;
    
      Array<double,1>theta_b;
    
      } outer;
    
      struct inner {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      Array<double,1>psi;
    
      Array<double,1>theta_b;
    
      } inner;
    
      } midplane;
    
      struct turning_pts {
      
      struct upper {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      Array<double,1>psi;
    
      Array<double,1>theta_b;
    
      } upper;
    
      struct lower {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      Array<double,1>psi;
    
      Array<double,1>theta_b;
    
      } lower;
    
      } turning_pts;
    
      } special_pos;
    
      } orb_glob_dat;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      double time;
    orbit();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const orbit&obj);
};
class orbitArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    orbitArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <orbit,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    orbit &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class pfsystems:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct pfcoils {
      
      struct desc_pfcoils {
      
     Array<std::string,1>name;
    
     Array<std::string,1>id;
    
      Array<double,1>res;
    
      Array<double,1>emax;
    
     Array<int,1>nelement;
    
      struct pfelement {
      
     Array<std::string,1>name;
    
     Array<std::string,1>id;
    
    Array<double,2>turnsign;
    
    Array<double,2>area;
    
      struct pfgeometry {
      
    Array<int,2>type;
    
    Array<int,2>npoints;
    
      struct rzcoordinate {
      
    Array<double,3>r;
    
    Array<double,3>z;
    
      } rzcoordinate;
    
    Array<double,3>rzdrdz;
    
      } pfgeometry;
    
      } pfelement;
    
      } desc_pfcoils;
    
      struct coilcurrent {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } coilcurrent;
    
      struct coilvoltage {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } coilvoltage;
    
      } pfcoils;
    
      struct pfpassive {
      
      Array<double,1>area;
    
      Array<double,1>res;
    
      struct pfpageometry {
      
     Array<int,1>type;
    
     Array<int,1>npoints;
    
      struct rzcoordinate {
      
    Array<double,2>r;
    
    Array<double,2>z;
    
      } rzcoordinate;
    
    Array<double,2>rzdrdz;
    
      } pfpageometry;
    
      } pfpassive;
    
      struct pfcircuits {
      
     Array<std::string,1>name;
    
     Array<std::string,1>id;
    
     Array<std::string,1>type;
    
     Array<int,1>nnodes;
    
     Array<int,3>connections;
    
      } pfcircuits;
    
      struct pfsupplies {
      
      struct desc_supply {
      
     Array<std::string,1>name;
    
     Array<std::string,1>id;
    
     Array<std::string,1>type;
    
      Array<double,1>delay;
    
      struct filter {
      
    Array<double,2>num;
    
    Array<double,2>den;
    
      } filter;
    
      Array<double,1>imin;
    
      Array<double,1>imax;
    
      Array<double,1>res;
    
      Array<double,1>umin;
    
      Array<double,1>umax;
    
      Array<double,1>emax;
    
      } desc_supply;
    
      struct voltage {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } voltage;
    
      struct current {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } current;
    
      } pfsupplies;
    
      double time;
    pfsystems();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const pfsystems&obj);
};
class pfsystemsArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    pfsystemsArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <pfsystems,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    pfsystems &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class polardiag:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      std::string expression;
    
      struct setup_line {
      
      struct pivot_point {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      Array<double,1>phi;
    
      } pivot_point;
    
      Array<double,1>horchordang1;
    
      Array<double,1>verchordang1;
    
      Array<double,1>width;
    
      struct second_point {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      Array<double,1>phi;
    
      } second_point;
    
      Array<double,1>horchordang2;
    
      Array<double,1>verchordang2;
    
      struct third_point {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      Array<double,1>phi;
    
      } third_point;
    
      int nchordpoints;
    
      } setup_line;
    
      struct measure {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } measure;
    
      double time;
    polardiag();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const polardiag&obj);
};
class polardiagArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    polardiagArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <polardiag,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    polardiag &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class reference:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct non_timed {
      
      struct zerod_real {
      
      struct ref1 {
      
      double value;
    
      std::string description;
    
      } ref1;
    
      struct ref2 {
      
      double value;
    
      std::string description;
    
      } ref2;
    
      struct ref3 {
      
      double value;
    
      std::string description;
    
      } ref3;
    
      struct ref4 {
      
      double value;
    
      std::string description;
    
      } ref4;
    
      struct ref5 {
      
      double value;
    
      std::string description;
    
      } ref5;
    
      struct ref6 {
      
      double value;
    
      std::string description;
    
      } ref6;
    
      struct ref7 {
      
      double value;
    
      std::string description;
    
      } ref7;
    
      } zerod_real;
    
      struct zerod_int {
      
      struct ref1 {
      
      int value;
    
      std::string description;
    
      } ref1;
    
      struct ref2 {
      
      int value;
    
      std::string description;
    
      } ref2;
    
      struct ref3 {
      
      int value;
    
      std::string description;
    
      } ref3;
    
      struct ref4 {
      
      int value;
    
      std::string description;
    
      } ref4;
    
      } zerod_int;
    
      struct zerod_string {
      
      struct ref1 {
      
      std::string value;
    
      std::string description;
    
      } ref1;
    
      struct ref2 {
      
      std::string value;
    
      std::string description;
    
      } ref2;
    
      } zerod_string;
    
      struct oned_real {
      
      struct ref1 {
      
      Array<double,1>value;
    
      std::string description;
    
      } ref1;
    
      struct ref2 {
      
      Array<double,1>value;
    
      std::string description;
    
      } ref2;
    
      struct ref3 {
      
      Array<double,1>value;
    
      std::string description;
    
      } ref3;
    
      struct ref4 {
      
      Array<double,1>value;
    
      std::string description;
    
      } ref4;
    
      struct ref5 {
      
      Array<double,1>value;
    
      std::string description;
    
      } ref5;
    
      } oned_real;
    
      struct oned_int {
      
      struct ref1 {
      
     Array<int,1>value;
    
      std::string description;
    
      } ref1;
    
      struct ref2 {
      
     Array<int,1>value;
    
      std::string description;
    
      } ref2;
    
      struct ref3 {
      
     Array<int,1>value;
    
      std::string description;
    
      } ref3;
    
      struct ref4 {
      
     Array<int,1>value;
    
      std::string description;
    
      } ref4;
    
      } oned_int;
    
      } non_timed;
    
      struct timed {
      
      struct zerod_real {
      
      struct ref1 {
      
      double value;
    
      std::string description;
    
      } ref1;
    
      struct ref2 {
      
      double value;
    
      std::string description;
    
      } ref2;
    
      struct ref3 {
      
      double value;
    
      std::string description;
    
      } ref3;
    
      struct ref4 {
      
      double value;
    
      std::string description;
    
      } ref4;
    
      struct ref5 {
      
      double value;
    
      std::string description;
    
      } ref5;
    
      struct ref6 {
      
      double value;
    
      std::string description;
    
      } ref6;
    
      struct ref7 {
      
      double value;
    
      std::string description;
    
      } ref7;
    
      struct ref8 {
      
      double value;
    
      std::string description;
    
      } ref8;
    
      struct ref9 {
      
      double value;
    
      std::string description;
    
      } ref9;
    
      struct ref10 {
      
      double value;
    
      std::string description;
    
      } ref10;
    
      } zerod_real;
    
      struct zerod_int {
      
      struct ref1 {
      
      int value;
    
      std::string description;
    
      } ref1;
    
      struct ref2 {
      
      int value;
    
      std::string description;
    
      } ref2;
    
      struct ref3 {
      
      int value;
    
      std::string description;
    
      } ref3;
    
      struct ref4 {
      
      int value;
    
      std::string description;
    
      } ref4;
    
      } zerod_int;
    
      struct oned_real {
      
      struct ref1 {
      
      Array<double,1>value;
    
      std::string description;
    
      } ref1;
    
      struct ref2 {
      
      Array<double,1>value;
    
      std::string description;
    
      } ref2;
    
      struct ref3 {
      
      Array<double,1>value;
    
      std::string description;
    
      } ref3;
    
      struct ref4 {
      
      Array<double,1>value;
    
      std::string description;
    
      } ref4;
    
      struct ref5 {
      
      Array<double,1>value;
    
      std::string description;
    
      } ref5;
    
      } oned_real;
    
      struct oned_int {
      
      struct ref1 {
      
     Array<int,1>value;
    
      std::string description;
    
      } ref1;
    
      struct ref2 {
      
     Array<int,1>value;
    
      std::string description;
    
      } ref2;
    
      struct ref3 {
      
     Array<int,1>value;
    
      std::string description;
    
      } ref3;
    
      struct ref4 {
      
     Array<int,1>value;
    
      std::string description;
    
      } ref4;
    
      } oned_int;
    
      } timed;
    
      double time;
    reference();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const reference&obj);
};
class referenceArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    referenceArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <reference,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    reference &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class sawteeth:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      int crash_trig;
    
      struct composition {
      
      Array<double,1>amn;
    
      Array<double,1>zn;
    
      Array<double,1>zion;
    
     Array<int,1>imp_flag;
    
      } composition;
    
      Array<double,1>rho_tor_norm;
    
      Array<double,1>rho_tor;
    
      struct profiles1d {
      
      Array<double,1>ne;
    
    Array<double,2>ni;
    
      Array<double,1>te;
    
    Array<double,2>ti;
    
      Array<double,1>psi;
    
      Array<double,1>phi;
    
      Array<double,1>psistar;
    
      Array<double,1>volume;
    
      Array<double,1>q;
    
      } profiles1d;
    
      struct diags {
      
      double shear1;
    
      double rhotorn_q1;
    
      double rhotorn_inv;
    
      double rhotorn_mix;
    
      } diags;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      double time;
    sawteeth();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const sawteeth&obj);
};
class sawteethArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    sawteethArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <sawteeth,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    sawteeth &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class scenario:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct centre {
      
      struct te0 {
      
      double value;
    
      std::string source;
    
      } te0;
    
      struct ti0 {
      
      double value;
    
      std::string source;
    
      } ti0;
    
      struct ne0 {
      
      double value;
    
      std::string source;
    
      } ne0;
    
      struct ni0 {
      
      double value;
    
      std::string source;
    
      } ni0;
    
      struct shift0 {
      
      double value;
    
      std::string source;
    
      } shift0;
    
      struct psi0 {
      
      double value;
    
      std::string source;
    
      } psi0;
    
      struct phi0 {
      
      double value;
    
      std::string source;
    
      } phi0;
    
      struct q0 {
      
      double value;
    
      std::string source;
    
      } q0;
    
      struct Rmag {
      
      double value;
    
      std::string source;
    
      } Rmag;
    
      struct Zmag {
      
      double value;
    
      std::string source;
    
      } Zmag;
    
      struct vtor_0 {
      
      double value;
    
      std::string source;
    
      } vtor_0;
    
      } centre;
    
      struct composition {
      
      Array<double,1>amn;
    
      Array<double,1>zn;
    
      Array<double,1>zion;
    
     Array<int,1>imp_flag;
    
     Array<int,1>rot_imp_flag;
    
      Array<double,1>pellet_amn;
    
      Array<double,1>pellet_zn;
    
      Array<double,1>nbi_amn;
    
      Array<double,1>nbi_zn;
    
      } composition;
    
      struct configs {
      
      struct config {
      
      int value;
    
      std::string source;
    
      } config;
    
      std::string lmode_sc;
    
      std::string hmode_sc;
    
      std::string core_sc;
    
      std::string pedestal_sc;
    
      std::string helium_sc;
    
      std::string impurity_sc;
    
      std::string l2h_sc;
    
      std::string tor_rot_sc;
    
      std::string wall_mat;
    
      std::string evap_mat;
    
      std::string lim_mat;
    
      std::string div_mat;
    
      std::string coordinate;
    
      struct ecrh_freq {
      
      double value;
    
      std::string source;
    
      } ecrh_freq;
    
      struct ecrh_loc {
      
      double value;
    
      std::string source;
    
      } ecrh_loc;
    
      struct ecrh_mode {
      
      int value;
    
      std::string source;
    
      } ecrh_mode;
    
      struct ecrh_tor_ang {
      
      double value;
    
      std::string source;
    
      } ecrh_tor_ang;
    
      struct ecrh_pol_ang {
      
      double value;
    
      std::string source;
    
      } ecrh_pol_ang;
    
      struct ecrh_harm {
      
      int value;
    
      std::string source;
    
      } ecrh_harm;
    
      struct enbi {
      
      double value;
    
      std::string source;
    
      } enbi;
    
      struct r_nbi {
      
      double value;
    
      std::string source;
    
      } r_nbi;
    
      struct grad_b_drift {
      
      int value;
    
      std::string source;
    
      } grad_b_drift;
    
      struct icrh_freq {
      
      double value;
    
      std::string source;
    
      } icrh_freq;
    
      std::string icrh_scheme;
    
      struct icrh_phase {
      
      double value;
    
      std::string source;
    
      } icrh_phase;
    
      struct LH_freq {
      
      double value;
    
      std::string source;
    
      } LH_freq;
    
      struct LH_npar {
      
      double value;
    
      std::string source;
    
      } LH_npar;
    
      struct pellet_ang {
      
      double value;
    
      std::string source;
    
      } pellet_ang;
    
      struct pellet_v {
      
      double value;
    
      std::string source;
    
      } pellet_v;
    
      struct pellet_nba {
      
      double value;
    
      std::string source;
    
      } pellet_nba;
    
      } configs;
    
      struct confinement {
      
      struct tau_e {
      
      double value;
    
      std::string source;
    
      } tau_e;
    
      struct tau_l_sc {
      
      double value;
    
      std::string source;
    
      } tau_l_sc;
    
      struct tau_h_sc {
      
      double value;
    
      std::string source;
    
      } tau_h_sc;
    
      struct tau_he {
      
      double value;
    
      std::string source;
    
      } tau_he;
    
      struct tau_e_ee {
      
      double value;
    
      std::string source;
    
      } tau_e_ee;
    
      struct tau_e_ii {
      
      double value;
    
      std::string source;
    
      } tau_e_ii;
    
      struct tau_e_ei {
      
      double value;
    
      std::string source;
    
      } tau_e_ei;
    
      struct tau_cur_diff {
      
      double value;
    
      std::string source;
    
      } tau_cur_diff;
    
      struct tau_i_rol {
      
      double value;
    
      std::string source;
    
      } tau_i_rol;
    
      } confinement;
    
      struct currents {
      
      struct RR {
      
      double value;
    
      std::string source;
    
      } RR;
    
      struct i_align {
      
      double value;
    
      std::string source;
    
      } i_align;
    
      struct i_boot {
      
      double value;
    
      std::string source;
    
      } i_boot;
    
      struct i_cd_tot {
      
      double value;
    
      std::string source;
    
      } i_cd_tot;
    
      struct i_eccd {
      
      double value;
    
      std::string source;
    
      } i_eccd;
    
      struct i_fast_ion {
      
      double value;
    
      std::string source;
    
      } i_fast_ion;
    
      struct i_fwcd {
      
      double value;
    
      std::string source;
    
      } i_fwcd;
    
      struct i_lhcd {
      
      double value;
    
      std::string source;
    
      } i_lhcd;
    
      struct i_nbicd {
      
      double value;
    
      std::string source;
    
      } i_nbicd;
    
      struct i_ni_tot {
      
      double value;
    
      std::string source;
    
      } i_ni_tot;
    
      struct i_ohm {
      
      double value;
    
      std::string source;
    
      } i_ohm;
    
      struct i_par {
      
      double value;
    
      std::string source;
    
      } i_par;
    
      struct i_runaway {
      
      double value;
    
      std::string source;
    
      } i_runaway;
    
      struct v_loop {
      
      double value;
    
      std::string source;
    
      } v_loop;
    
      struct v_meas {
      
      double value;
    
      std::string source;
    
      } v_meas;
    
      } currents;
    
      struct edge {
      
      struct te_edge {
      
      double value;
    
      std::string source;
    
      } te_edge;
    
      struct ti_edge {
      
      double value;
    
      std::string source;
    
      } ti_edge;
    
      struct ne_edge {
      
      double value;
    
      std::string source;
    
      } ne_edge;
    
      struct ni_edge {
      
      double value;
    
      std::string source;
    
      } ni_edge;
    
      struct psi_edge {
      
      double value;
    
      std::string source;
    
      } psi_edge;
    
      struct phi_edge {
      
      double value;
    
      std::string source;
    
      } phi_edge;
    
      struct rho_edge {
      
      double value;
    
      std::string source;
    
      } rho_edge;
    
      struct drho_edge_dt {
      
      double value;
    
      std::string source;
    
      } drho_edge_dt;
    
      struct q_edge {
      
      double value;
    
      std::string source;
    
      } q_edge;
    
      struct neutral_flux {
      
      double value;
    
      std::string source;
    
      } neutral_flux;
    
      struct phi_plasma {
      
      double value;
    
      std::string source;
    
      } phi_plasma;
    
      struct vtor_edge {
      
      double value;
    
      std::string source;
    
      } vtor_edge;
    
      } edge;
    
      struct energy {
      
      struct w_tot {
      
      double value;
    
      std::string source;
    
      } w_tot;
    
      struct w_b_pol {
      
      double value;
    
      std::string source;
    
      } w_b_pol;
    
      struct w_dia {
      
      double value;
    
      std::string source;
    
      } w_dia;
    
      struct dwdia_dt {
      
      double value;
    
      std::string source;
    
      } dwdia_dt;
    
      struct w_b_tor_pla {
      
      double value;
    
      std::string source;
    
      } w_b_tor_pla;
    
      struct w_th {
      
      double value;
    
      std::string source;
    
      } w_th;
    
      struct dwtot_dt {
      
      double value;
    
      std::string source;
    
      } dwtot_dt;
    
      struct dwbpol_dt {
      
      double value;
    
      std::string source;
    
      } dwbpol_dt;
    
      struct dwbtorpla_dt {
      
      double value;
    
      std::string source;
    
      } dwbtorpla_dt;
    
      struct dwth_dt {
      
      double value;
    
      std::string source;
    
      } dwth_dt;
    
      struct esup_icrhtot {
      
      double value;
    
      std::string source;
    
      } esup_icrhtot;
    
      struct esup_icrhper {
      
      double value;
    
      std::string source;
    
      } esup_icrhper;
    
      struct esup_nbitot {
      
      double value;
    
      std::string source;
    
      } esup_nbitot;
    
      struct esup_nbiperp {
      
      double value;
    
      std::string source;
    
      } esup_nbiperp;
    
      struct esup_lhcd {
      
      double value;
    
      std::string source;
    
      } esup_lhcd;
    
      struct esup_alpha {
      
      double value;
    
      std::string source;
    
      } esup_alpha;
    
      } energy;
    
      struct eqgeometry {
      
      std::string source;
    
      int boundarytype;
    
      struct boundary {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      int npoints;
    
      } boundary;
    
      struct geom_axis {
      
      double r;
    
      double z;
    
      } geom_axis;
    
      double a_minor;
    
      double elongation;
    
      double tria_upper;
    
      double tria_lower;
    
      struct xpts {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      } xpts;
    
      struct left_low_st {
      
      double r;
    
      double z;
    
      } left_low_st;
    
      struct right_low_st {
      
      double r;
    
      double z;
    
      } right_low_st;
    
      struct left_up_st {
      
      double r;
    
      double z;
    
      } left_up_st;
    
      struct right_up_st {
      
      double r;
    
      double z;
    
      } right_up_st;
    
      struct active_limit {
      
      double r;
    
      double z;
    
      } active_limit;
    
      } eqgeometry;
    
      struct global_param {
      
      struct ip {
      
      double value;
    
      std::string source;
    
      } ip;
    
      struct dip_dt {
      
      double value;
    
      std::string source;
    
      } dip_dt;
    
      struct beta_pol {
      
      double value;
    
      std::string source;
    
      } beta_pol;
    
      struct beta_tor {
      
      double value;
    
      std::string source;
    
      } beta_tor;
    
      struct beta_normal {
      
      double value;
    
      std::string source;
    
      } beta_normal;
    
      struct li {
      
      double value;
    
      std::string source;
    
      } li;
    
      struct volume {
      
      double value;
    
      std::string source;
    
      } volume;
    
      struct area_pol {
      
      double value;
    
      std::string source;
    
      } area_pol;
    
      struct area_ext {
      
      double value;
    
      std::string source;
    
      } area_ext;
    
      struct len_sepa {
      
      double value;
    
      std::string source;
    
      } len_sepa;
    
      struct beta_pol_th {
      
      double value;
    
      std::string source;
    
      } beta_pol_th;
    
      struct beta_tor_th {
      
      double value;
    
      std::string source;
    
      } beta_tor_th;
    
      struct beta_n_th {
      
      double value;
    
      std::string source;
    
      } beta_n_th;
    
      struct disruption {
      
      double value;
    
      std::string source;
    
      } disruption;
    
      struct mode_h {
      
      double value;
    
      std::string source;
    
      } mode_h;
    
      struct s_alpha {
      
      double value;
    
      std::string source;
    
      } s_alpha;
    
      } global_param;
    
      struct heat_power {
      
      struct plh {
      
      double value;
    
      std::string source;
    
      } plh;
    
      struct pohmic {
      
      double value;
    
      std::string source;
    
      } pohmic;
    
      struct picrh {
      
      double value;
    
      std::string source;
    
      } picrh;
    
      struct pecrh {
      
      double value;
    
      std::string source;
    
      } pecrh;
    
      struct pnbi {
      
      double value;
    
      std::string source;
    
      } pnbi;
    
      struct pnbi_co_cur {
      
      double value;
    
      std::string source;
    
      } pnbi_co_cur;
    
      struct pnbi_counter {
      
      double value;
    
      std::string source;
    
      } pnbi_counter;
    
      struct plh_th {
      
      double value;
    
      std::string source;
    
      } plh_th;
    
      struct picrh_th {
      
      double value;
    
      std::string source;
    
      } picrh_th;
    
      struct pecrh_th {
      
      double value;
    
      std::string source;
    
      } pecrh_th;
    
      struct pnbi_th {
      
      double value;
    
      std::string source;
    
      } pnbi_th;
    
      struct ploss_icrh {
      
      double value;
    
      std::string source;
    
      } ploss_icrh;
    
      struct ploss_nbi {
      
      double value;
    
      std::string source;
    
      } ploss_nbi;
    
      struct pbrem {
      
      double value;
    
      std::string source;
    
      } pbrem;
    
      struct pcyclo {
      
      double value;
    
      std::string source;
    
      } pcyclo;
    
      struct prad {
      
      double value;
    
      std::string source;
    
      } prad;
    
      struct pdd_fus {
      
      double value;
    
      std::string source;
    
      } pdd_fus;
    
      struct pei {
      
      double value;
    
      std::string source;
    
      } pei;
    
      struct pel_tot {
      
      double value;
    
      std::string source;
    
      } pel_tot;
    
      struct pel_fus {
      
      double value;
    
      std::string source;
    
      } pel_fus;
    
      struct pel_icrh {
      
      double value;
    
      std::string source;
    
      } pel_icrh;
    
      struct pel_nbi {
      
      double value;
    
      std::string source;
    
      } pel_nbi;
    
      struct pfus_dt {
      
      double value;
    
      std::string source;
    
      } pfus_dt;
    
      struct ploss_fus {
      
      double value;
    
      std::string source;
    
      } ploss_fus;
    
      struct pfus_nbi {
      
      double value;
    
      std::string source;
    
      } pfus_nbi;
    
      struct pfus_th {
      
      double value;
    
      std::string source;
    
      } pfus_th;
    
      struct padd_tot {
      
      double value;
    
      std::string source;
    
      } padd_tot;
    
      struct pion_tot {
      
      double value;
    
      std::string source;
    
      } pion_tot;
    
      struct pion_fus {
      
      double value;
    
      std::string source;
    
      } pion_fus;
    
      struct pion_icrh {
      
      double value;
    
      std::string source;
    
      } pion_icrh;
    
      struct pion_nbi {
      
      double value;
    
      std::string source;
    
      } pion_nbi;
    
      struct pioniz {
      
      double value;
    
      std::string source;
    
      } pioniz;
    
      struct ploss {
      
      double value;
    
      std::string source;
    
      } ploss;
    
      struct p_wth {
      
      double value;
    
      std::string source;
    
      } p_wth;
    
      struct p_w {
      
      double value;
    
      std::string source;
    
      } p_w;
    
      struct p_l2h_thr {
      
      double value;
    
      std::string source;
    
      } p_l2h_thr;
    
      struct p_l2h_sc {
      
      double value;
    
      std::string source;
    
      } p_l2h_sc;
    
      struct p_nbi_icrh {
      
      double value;
    
      std::string source;
    
      } p_nbi_icrh;
    
      } heat_power;
    
      struct itb {
      
      struct q_min {
      
      double value;
    
      std::string source;
    
      } q_min;
    
      struct te_itb {
      
      double value;
    
      std::string source;
    
      } te_itb;
    
      struct ti_itb {
      
      double value;
    
      std::string source;
    
      } ti_itb;
    
      struct ne_itb {
      
      double value;
    
      std::string source;
    
      } ne_itb;
    
      struct ni_itb {
      
      double value;
    
      std::string source;
    
      } ni_itb;
    
      struct psi_itb {
      
      double value;
    
      std::string source;
    
      } psi_itb;
    
      struct phi_itb {
      
      double value;
    
      std::string source;
    
      } phi_itb;
    
      struct rho_itb {
      
      double value;
    
      std::string source;
    
      } rho_itb;
    
      struct h_itb {
      
      double value;
    
      std::string source;
    
      } h_itb;
    
      struct width_itb {
      
      double value;
    
      std::string source;
    
      } width_itb;
    
      struct vtor_itb {
      
      double value;
    
      std::string source;
    
      } vtor_itb;
    
      struct itb_type {
      
      int value;
    
      std::string source;
    
      } itb_type;
    
      } itb;
    
      struct lim_div_wall {
      
      struct te_lim_div {
      
      double value;
    
      std::string source;
    
      } te_lim_div;
    
      struct ti_lim_div {
      
      double value;
    
      std::string source;
    
      } ti_lim_div;
    
      struct ne_lim_div {
      
      double value;
    
      std::string source;
    
      } ne_lim_div;
    
      struct ni_lim_div {
      
      double value;
    
      std::string source;
    
      } ni_lim_div;
    
      struct p_peak_div {
      
      double value;
    
      std::string source;
    
      } p_peak_div;
    
      struct surf_temp {
      
      double value;
    
      std::string source;
    
      } surf_temp;
    
      struct p_lim_div {
      
      double value;
    
      std::string source;
    
      } p_lim_div;
    
      struct p_rad_div {
      
      double value;
    
      std::string source;
    
      } p_rad_div;
    
      struct wall_temp {
      
      double value;
    
      std::string source;
    
      } wall_temp;
    
      struct wall_state {
      
      double value;
    
      std::string source;
    
      } wall_state;
    
      struct detach_state {
      
      double value;
    
      std::string source;
    
      } detach_state;
    
      Array<double,1>pump_flux;
    
      } lim_div_wall;
    
      struct line_ave {
      
      struct ne_line {
      
      double value;
    
      std::string source;
    
      } ne_line;
    
      struct zeff_line {
      
      double value;
    
      std::string source;
    
      } zeff_line;
    
      struct ne_zeff_line {
      
      double value;
    
      std::string source;
    
      } ne_zeff_line;
    
      struct dne_line_dt {
      
      double value;
    
      std::string source;
    
      } dne_line_dt;
    
      } line_ave;
    
      struct neutron {
      
      struct ndd_tot {
      
      double value;
    
      std::string source;
    
      } ndd_tot;
    
      struct ndd_th {
      
      double value;
    
      std::string source;
    
      } ndd_th;
    
      struct ndd_nbi_th {
      
      double value;
    
      std::string source;
    
      } ndd_nbi_th;
    
      struct ndd_nbi_nbi {
      
      double value;
    
      std::string source;
    
      } ndd_nbi_nbi;
    
      struct ndt_tot {
      
      double value;
    
      std::string source;
    
      } ndt_tot;
    
      struct ndt_th {
      
      double value;
    
      std::string source;
    
      } ndt_th;
    
      } neutron;
    
      struct ninety_five {
      
      struct q_95 {
      
      double value;
    
      std::string source;
    
      } q_95;
    
      struct elong_95 {
      
      double value;
    
      std::string source;
    
      } elong_95;
    
      struct tria_95 {
      
      double value;
    
      std::string source;
    
      } tria_95;
    
      struct tria_up_95 {
      
      double value;
    
      std::string source;
    
      } tria_up_95;
    
      struct tria_lo_95 {
      
      double value;
    
      std::string source;
    
      } tria_lo_95;
    
      struct te_95 {
      
      double value;
    
      std::string source;
    
      } te_95;
    
      struct ti_95 {
      
      double value;
    
      std::string source;
    
      } ti_95;
    
      struct ne_95 {
      
      double value;
    
      std::string source;
    
      } ne_95;
    
      struct ni_95 {
      
      double value;
    
      std::string source;
    
      } ni_95;
    
      struct phi_95 {
      
      double value;
    
      std::string source;
    
      } phi_95;
    
      struct rho_95 {
      
      double value;
    
      std::string source;
    
      } rho_95;
    
      struct vtor_95 {
      
      double value;
    
      std::string source;
    
      } vtor_95;
    
      } ninety_five;
    
      struct pedestal {
      
      struct te_ped {
      
      double value;
    
      std::string source;
    
      } te_ped;
    
      struct ti_ped {
      
      double value;
    
      std::string source;
    
      } ti_ped;
    
      struct ne_ped {
      
      double value;
    
      std::string source;
    
      } ne_ped;
    
      struct ni_ped {
      
      double value;
    
      std::string source;
    
      } ni_ped;
    
      struct psi_ped {
      
      double value;
    
      std::string source;
    
      } psi_ped;
    
      struct phi_ped {
      
      double value;
    
      std::string source;
    
      } phi_ped;
    
      struct rho_ped {
      
      double value;
    
      std::string source;
    
      } rho_ped;
    
      struct q_ped {
      
      double value;
    
      std::string source;
    
      } q_ped;
    
      struct pressure_ped {
      
      double value;
    
      std::string source;
    
      } pressure_ped;
    
      struct vtor_ped {
      
      double value;
    
      std::string source;
    
      } vtor_ped;
    
      } pedestal;
    
      struct references {
      
      struct plh {
      
      double value;
    
      std::string source;
    
      } plh;
    
      struct picrh {
      
      double value;
    
      std::string source;
    
      } picrh;
    
      struct pecrh {
      
      double value;
    
      std::string source;
    
      } pecrh;
    
      struct pnbi {
      
      double value;
    
      std::string source;
    
      } pnbi;
    
      struct ip {
      
      double value;
    
      std::string source;
    
      } ip;
    
      struct bvac_r {
      
      double value;
    
      std::string source;
    
      } bvac_r;
    
      struct zeffl {
      
      double value;
    
      std::string source;
    
      } zeffl;
    
      struct nbar {
      
      double value;
    
      std::string source;
    
      } nbar;
    
      struct xecrh {
      
      double value;
    
      std::string source;
    
      } xecrh;
    
      struct pol_flux {
      
      double value;
    
      std::string source;
    
      } pol_flux;
    
      struct enhancement {
      
      double value;
    
      std::string source;
    
      } enhancement;
    
      struct isotopic {
      
      double value;
    
      std::string source;
    
      } isotopic;
    
      struct nbi_td_ratio {
      
      double value;
    
      std::string source;
    
      } nbi_td_ratio;
    
      } references;
    
      struct reactor {
      
      double pnetwork;
    
      } reactor;
    
      struct sol {
      
      struct l_te_sol {
      
      double value;
    
      std::string source;
    
      } l_te_sol;
    
      struct l_ti_sol {
      
      double value;
    
      std::string source;
    
      } l_ti_sol;
    
      struct l_ne_sol {
      
      double value;
    
      std::string source;
    
      } l_ne_sol;
    
      struct l_ni_sol {
      
      double value;
    
      std::string source;
    
      } l_ni_sol;
    
      struct l_qe_sol {
      
      double value;
    
      std::string source;
    
      } l_qe_sol;
    
      struct l_qi_sol {
      
      double value;
    
      std::string source;
    
      } l_qi_sol;
    
      struct p_rad_sol {
      
      double value;
    
      std::string source;
    
      } p_rad_sol;
    
      Array<double,1>gaz_puff;
    
      } sol;
    
      struct vol_ave {
      
      struct te_ave {
      
      double value;
    
      std::string source;
    
      } te_ave;
    
      struct ti_ave {
      
      double value;
    
      std::string source;
    
      } ti_ave;
    
      struct ne_ave {
      
      double value;
    
      std::string source;
    
      } ne_ave;
    
      struct dne_ave_dt {
      
      double value;
    
      std::string source;
    
      } dne_ave_dt;
    
      struct ni_ave {
      
      double value;
    
      std::string source;
    
      } ni_ave;
    
      struct zeff_ave {
      
      double value;
    
      std::string source;
    
      } zeff_ave;
    
      struct ti_o_te_ave {
      
      double value;
    
      std::string source;
    
      } ti_o_te_ave;
    
      struct meff_ave {
      
      double value;
    
      std::string source;
    
      } meff_ave;
    
      struct pellet_flux {
      
      double value;
    
      std::string source;
    
      } pellet_flux;
    
      Array<double,1>nions_ave;
    
      struct omega_ave {
      
      double value;
    
      std::string source;
    
      } omega_ave;
    
      } vol_ave;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      double time;
    scenario();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const scenario&obj);
};
class scenarioArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    scenarioArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <scenario,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    scenario &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class toroidfield:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      int nturns;
    
      int ncoils;
    
      struct current {
      
      double value;
    
      double abserror;
    
      double relerror;
    
      } current;
    
      struct bvac_r {
      
      double value;
    
      double abserror;
    
      double relerror;
    
      } bvac_r;
    
      double r0;
    
      double time;
    toroidfield();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const toroidfield&obj);
};
class toroidfieldArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    toroidfieldArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <toroidfield,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    toroidfield &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
class tsdiag:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct setup {
      
      struct position {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      } position;
    
      } setup;
    
      struct measure {
      
      struct te {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } te;
    
      struct ne {
      
      Array<double,1>value;
    
      Array<double,1>abserror;
    
      Array<double,1>relerror;
    
      } ne;
    
      } measure;
    
      double time;
    tsdiag();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const tsdiag&obj);
};
class tsdiagArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    tsdiagArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <tsdiag,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    tsdiag &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  
          class vessel:Cpo
          {
          private:
          int expIdx;
          bool connected;
          public:
          
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct position {
      
      Array<double,1>r;
    
      Array<double,1>z;
    
      } position;
    vessel();
          void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
          int get();
          int get(int idx);
          int put();
          int put(int idx);
          friend ostream &operator << (ostream &os, const vessel&obj);

};
      
class waves:Cpo
{
    private:
      int expIdx;
      bool connected;
      public:
      void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
      
      struct datainfo {
      
      std::string dataprovider;
    
      std::string putdate;
    
      std::string source;
    
      std::string comment;
    
      int isref;
    
      struct whatref {
      
      std::string user;
    
      std::string machine;
    
      int shot;
    
      int run;
    
      int occurrence;
    
      } whatref;
    
      struct putinfo {
      
      std::string putmethod;
    
      std::string putaccess;
    
      std::string putlocation;
    
      std::string rights;
    
      } putinfo;
    
      } datainfo;
    
      struct composition {
      
      Array<double,1>amn;
    
      Array<double,1>zn;
    
      Array<double,1>zion;
    
     Array<int,1>imp_flag;
    
      } composition;
    
      struct global_param {
      
      Array<double,1>frequency;
    
     Array<std::string,1>name;
    
     Array<std::string,1>type;
    
     Array<int,1>nntor;
    
    Array<int,2>ntor;
    
    Array<int,2>f_assumption;
    
      Array<double,1>power_tot;
    
    Array<double,2>p_frac_ntor;
    
    Array<double,2>pow_i;
    
      Array<double,1>pow_e;
    
    Array<double,3>pow_ntor_i;
    
    Array<double,2>pow_ntor_e;
    
      Array<double,1>cur_tor;
    
    Array<double,2>cur_tor_ntor;
    
     Array<int,1>code_type;
    
     Array<int,1>freq_point;
    
      struct toroid_field {
      
      double r0;
    
      double b0;
    
      } toroid_field;
    
      } global_param;
    
      struct grid {
      
    Array<double,2>rho_tor_norm;
    
    Array<double,2>rho_tor;
    
    Array<double,2>psi;
    
    Array<double,2>theta;
    
     Array<int,1>npsi;
    
     Array<int,1>ntheta;
    
      struct rz_position {
      
    Array<double,3>r;
    
    Array<double,3>z;
    
      } rz_position;
    
      struct theta_info {
      
     Array<int,1>angl_type;
    
    Array<double,2>th2th_pol;
    
      } theta_info;
    
      } grid;
    
      struct profiles_1d {
      
    Array<double,2>powd_tot;
    
    Array<double,2>powd_e;
    
    Array<double,3>powd_i;
    
    Array<double,3>powd_ntor;
    
    Array<double,3>powd_ntor_e;
    
    Array<double,4>powd_ntor_i;
    
    Array<double,2>curd_tor;
    
    Array<double,3>curd_torntor;
    
    Array<double,2>pow_tot;
    
    Array<double,2>pow_e;
    
    Array<double,3>pow_i;
    
    Array<double,3>pow_ntor;
    
    Array<double,3>pow_ntor_e;
    
    Array<double,4>pow_ntor_i;
    
    Array<double,2>curd_par;
    
    Array<double,3>curd_parntor;
    
    Array<double,2>cur_tor;
    
    Array<double,3>cur_tor_ntor;
    
      } profiles_1d;
    
      struct profiles_2d {
      
    Array<double,3>powd_tot;
    
    Array<double,3>powd_e;
    
    Array<double,4>powd_i;
    
    Array<double,4>powd_ntor;
    
    Array<double,4>powd_ntor_e;
    
    Array<double,5>powd_ntor_i;
    
    Array<double,5>powd_iharm;
    
      } profiles_2d;
    
      struct beamtracing {
      
     Array<int,1>nbeams;
    
    Array<int,2>npoints;
    
    Array<double,2>power;
    
    Array<double,3>dnpar;
    
    Array<double,3>length;
    
      struct position {
      
    Array<double,3>r;
    
    Array<double,3>z;
    
    Array<double,3>psi;
    
    Array<double,3>theta;
    
    Array<double,3>phi;
    
      } position;
    
      struct wavevector {
      
    Array<double,3>kr;
    
    Array<double,3>kz;
    
    Array<double,3>npar;
    
    Array<double,3>nperp;
    
    Array<double,3>ntor;
    
     Array<int,1>var_ntor;
    
      } wavevector;
    
      struct polarization {
      
    Array<double,3>epol_p;
    
    Array<double,3>epol_m;
    
    Array<double,3>epol_par;
    
      } polarization;
    
      struct powerflow {
      
    Array<double,3>phi_perp;
    
    Array<double,3>phi_par;
    
    Array<double,3>power_e;
    
    Array<double,4>power_i;
    
      } powerflow;
    
      } beamtracing;
    
      struct fullwave {
      
      struct pol_decomp {
      
     Array<int,1>nmpol;
    
    Array<int,2>mpol;
    
    Array<double,4>e_plus;
    
    Array<double,4>e_plus_ph;
    
    Array<double,4>e_minus;
    
    Array<double,4>e_minus_ph;
    
    Array<double,4>e_norm;
    
    Array<double,4>e_norm_ph;
    
    Array<double,4>e_binorm;
    
    Array<double,4>e_binorm_ph;
    
    Array<double,4>e_para;
    
    Array<double,4>e_para_ph;
    
    Array<double,4>b_norm;
    
    Array<double,4>b_norm_ph;
    
    Array<double,4>b_binorm;
    
    Array<double,4>b_binorm_ph;
    
    Array<double,4>b_para;
    
    Array<double,4>b_para_ph;
    
      } pol_decomp;
    
      struct local {
      
    Array<double,4>e_plus;
    
    Array<double,4>e_plus_ph;
    
    Array<double,4>e_minus;
    
    Array<double,4>e_minus_ph;
    
    Array<double,4>e_norm;
    
    Array<double,4>enorm_ph;
    
    Array<double,4>e_binorm;
    
    Array<double,4>e_binorm_ph;
    
    Array<double,4>e_para;
    
    Array<double,4>e_para_ph;
    
    Array<double,4>b_norm;
    
    Array<double,4>b_norm_ph;
    
    Array<double,4>b_binorm;
    
    Array<double,4>b_binorm_ph;
    
    Array<double,4>b_para;
    
    Array<double,4>b_para_ph;
    
      } local;
    
      } fullwave;
    
      struct codeparam {
      
      std::string codename;
    
      std::string codeversion;
    
      std::string parameters;
    
      std::string output_diag;
    
      int output_flag;
    
      } codeparam;
    
      double time;
    waves();
    int getSlice(double inTime, char interpolMode);
    int getSlice(int idx, double inTime, char interpolMode);
    int putSlice();
    int putSlice(int idx);
    int replaceLastSlice();
    int replaceLastSlice(int idx);
    int remove();
    int remove(int idx);
    int putNonTimed();
    int putNonTimed(int idx);
    void discardMemCache();
    void flushCache();
    friend ostream &operator << (ostream &os, const waves&obj);
};
class wavesArray:Cpo
{
private:
          int expIdx;
	  bool connected;
          
          
public:
    wavesArray(){connected = false;}
    void setExpIdx(int expIdx){this->expIdx = expIdx; connected = true;}
    Array <waves,1 > array;

    int get();
    int put();
    int deleteAll();
    int deleteAll(int idx);
    int get(int idx);
    int put(int idx);
    waves &operator[] (int index) {return array(index);};
    int extent(int dim = 0) {return array.extent(dim);};
  };
  topinfo  
            _topinfo;
        summary  
            _summary;
        amns  
            _amns;
        antennas  
            _antennas;
            antennasArray
            _antennasArray;
        coredelta  
            _coredelta;
            coredeltaArray
            _coredeltaArray;
        coreneutrals  
            _coreneutrals;
            coreneutralsArray
            _coreneutralsArray;
        coreimpur  
            _coreimpur;
            coreimpurArray
            _coreimpurArray;
        coreprof  
            _coreprof;
            coreprofArray
            _coreprofArray;
        coresource  
            _coresource;
            coresourceArray
            _coresourceArray;
        coretransp  
            _coretransp;
            coretranspArray
            _coretranspArray;
        cxdiag  
            _cxdiag;
            cxdiagArray
            _cxdiagArray;
        distribution  
            _distribution;
            distributionArray
            _distributionArray;
        distsource  
            _distsource;
            distsourceArray
            _distsourceArray;
        ecediag  
            _ecediag;
            ecediagArray
            _ecediagArray;
        edge  
            _edge;
            edgeArray
            _edgeArray;
        equilibrium  
            _equilibrium;
            equilibriumArray
            _equilibriumArray;
        interfdiag  
            _interfdiag;
            interfdiagArray
            _interfdiagArray;
        ironmodel  
            _ironmodel;
            ironmodelArray
            _ironmodelArray;
        launchs  
            _launchs;
            launchsArray
            _launchsArray;
        limiter  
            _limiter;
        mhd  
            _mhd;
            mhdArray
            _mhdArray;
        magdiag  
            _magdiag;
            magdiagArray
            _magdiagArray;
        msediag  
            _msediag;
            msediagArray
            _msediagArray;
        nbi  
            _nbi;
            nbiArray
            _nbiArray;
        neoclassic  
            _neoclassic;
            neoclassicArray
            _neoclassicArray;
        orbit  
            _orbit;
            orbitArray
            _orbitArray;
        pfsystems  
            _pfsystems;
            pfsystemsArray
            _pfsystemsArray;
        polardiag  
            _polardiag;
            polardiagArray
            _polardiagArray;
        reference  
            _reference;
            referenceArray
            _referenceArray;
        sawteeth  
            _sawteeth;
            sawteethArray
            _sawteethArray;
        scenario  
            _scenario;
            scenarioArray
            _scenarioArray;
        toroidfield  
            _toroidfield;
            toroidfieldArray
            _toroidfieldArray;
        tsdiag  
            _tsdiag;
            tsdiagArray
            _tsdiagArray;
        vessel  
            _vessel;
        waves  
            _waves;
            wavesArray
            _wavesArray;
        

    };
}
 
 #endif