#ifndef _UAL_CLASSES

#define _UAL_CLASSES

// this definition is needed to avoid mutex problems with blitz++
#define BZ_THREADSAFE

#include "UALDef.h"
#include <blitz/array.h>

using namespace blitz;
namespace ItmNs {

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



     inline void checkObject(void *obj) {
        if (!obj)
            printf("Problem with array of structure allocation\n");
    } 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;
        }
        void setCacheLevel(int level) {
            euitm_set_cache_level(expIdx, level);
        }
        int getCacheLevel() {
            return euitm_get_cache_level(expIdx);
        }
        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();
        }
        void discardAll();
        void flushAll();
        void enableMemCache();
        void disableMemCache();
        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;

            class entry {
              public:

                std::string user;

                std::string machine;

                int shot;

                int run;
                 entry() {
                    shot = EMPTY_INT;
                    run = EMPTY_INT;

                };
            } entry;

            class parent_entry {
              public:

                std::string user;

                std::string machine;

                int shot;

                int run;
                 parent_entry() {
                    shot = EMPTY_INT;
                    run = EMPTY_INT;

                };
            } parent_entry;

            class mdinfo {
              public:

                int shot_min;

                int shot_max;

                class md_entry {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;
                     md_entry() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;

                    };
                } md_entry;
                mdinfo() {
                    shot_min = EMPTY_INT;
                    shot_max = EMPTY_INT;

                };
            } mdinfo;
            topinfo();
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            }
            int get();
            int get(int idx);
            int put();
            int put(int idx);
            void flush();
            void flush(int idx);
            void discard();
            void discard(int idx);
            friend ostream & operator <<(ostream & os, const topinfo & obj);

        };

        class summary:Cpo {
          private:
            int expIdx;
            bool connected;
          public:

             class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class ip {
              public:

                double value;

                 std::string source;

                double time;
                 ip() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } ip;

            class bvac_r {
              public:

                double value;

                 std::string source;

                double time;
                 bvac_r() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } bvac_r;

            class geom_axis_r {
              public:

                double value;

                 std::string source;

                double time;
                 geom_axis_r() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } geom_axis_r;

            class a_minor {
              public:

                double value;

                 std::string source;

                double time;
                 a_minor() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } a_minor;

            class elongation {
              public:

                double value;

                 std::string source;

                double time;
                 elongation() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } elongation;

            class tria_lower {
              public:

                double value;

                 std::string source;

                double time;
                 tria_lower() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } tria_lower;

            class tria_upper {
              public:

                double value;

                 std::string source;

                double time;
                 tria_upper() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } tria_upper;

            class tev {
              public:

                double value;

                 std::string source;

                double time;
                 tev() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } tev;

            class tiv {
              public:

                double value;

                 std::string source;

                double time;
                 tiv() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } tiv;

            class nev {
              public:

                double value;

                 std::string source;

                double time;
                 nev() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } nev;

            class zeffv {
              public:

                double value;

                 std::string source;

                double time;
                 zeffv() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } zeffv;

            class beta_pol {
              public:

                double value;

                 std::string source;

                double time;
                 beta_pol() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } beta_pol;

            class beta_tor {
              public:

                double value;

                 std::string source;

                double time;
                 beta_tor() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } beta_tor;

            class beta_normal {
              public:

                double value;

                 std::string source;

                double time;
                 beta_normal() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } beta_normal;

            class li {
              public:

                double value;

                 std::string source;

                double time;
                 li() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } li;

            class volume {
              public:

                double value;

                 std::string source;

                double time;
                 volume() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } volume;

            class area {
              public:

                double value;

                 std::string source;

                double time;
                 area() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } area;

            class main_ion1_z {
              public:

                double value;

                 std::string source;

                double time;
                 main_ion1_z() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } main_ion1_z;

            class main_ion1_a {
              public:

                double value;

                 std::string source;

                double time;
                 main_ion1_a() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } main_ion1_a;

            class main_ion2_z {
              public:

                double value;

                 std::string source;

                double time;
                 main_ion2_z() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } main_ion2_z;

            class main_ion2_a {
              public:

                double value;

                 std::string source;

                double time;
                 main_ion2_a() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } main_ion2_a;

            class impur1_z {
              public:

                double value;

                 std::string source;

                double time;
                 impur1_z() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } impur1_z;

            class impur1_a {
              public:

                double value;

                 std::string source;

                double time;
                 impur1_a() {
                    value = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } 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);
            void flush();
            void flush(int idx);
            void discard();
            void discard(int idx);
            friend ostream & operator <<(ostream & os, const summary & obj);

        };

        class amns:Cpo {
          private:
            int expIdx;
            bool connected;
          public:

             class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            std::string version;

            std::string source;

            int zn;

            double amn;

            Array < int, 1 > zion;

            Array < std::string, 1 > state_label;

            int bundled;

            Array < std::string, 1 > proc_label;

            class tables {
              public:

                int ndim;

                int coord_index;

                 std::string result_label;

                 std::string result_unit;

                int result_trans;

                class table {
                  public:

                    double table_0d;

                     Array < double, 1 > table_1d;

                     Array < double, 2 > table_2d;

                     Array < double, 3 > table_3d;

                     Array < double, 4 > table_4d;

                     Array < double, 5 > table_5d;

                     Array < double, 6 > table_6d;
                     table() {
                        table_0d = EMPTY_DOUBLE;

                    };
                };
                Array < class table, 1 > table;

                std::string data_source;

                std::string data_provide;

                std::string data_citation;
                tables() {
                    ndim = EMPTY_INT;
                    coord_index = EMPTY_INT;
                    result_trans = EMPTY_INT;

                };
            };
            Array < class tables, 1 > tables;

            class tables_coord {
              public:

                class coords {
                  public:

                    Array < double, 1 > coord;

                     Array < std::string, 1 > coord_label;

                     Array < int, 1 > extrap_type;

                    int interp_type;

                     std::string label;

                     std::string unit;

                    int transform;

                    int spacing;
                     coords() {
                        interp_type = EMPTY_INT;
                        transform = EMPTY_INT;
                        spacing = EMPTY_INT;

                    };
                };
                Array < class coords, 1 > coords;
                tables_coord() {

                };
            };
            Array < class tables_coord, 1 > tables_coord;

            class version_ind {
              public:

                Array < std::string, 1 > description;

                std::string releasedate;

                class data_release {
                  public:

                    int shot;

                    int run;

                     Array < std::string, 1 > description;
                     data_release() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;

                    };
                };
                Array < class data_release, 1 > data_release;
                version_ind() {

                };
            };
            Array < class version_ind, 1 > version_ind;
            amns();
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            }
            int get();
            int get(int idx);
            int put();
            int put(int idx);
            void flush();
            void flush(int idx);
            void discard();
            void discard(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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class antenna_ec {
              public:

                std::string name;

                double frequency;

                class power {
                  public:

                    double value;

                    double abserror;

                    double relerror;
                     power() {
                        value = EMPTY_DOUBLE;
                        abserror = EMPTY_DOUBLE;
                        relerror = EMPTY_DOUBLE;

                    };
                } power;

                int mode;

                class position {
                  public:

                    double r;

                    double z;

                    double phi;
                     position() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;
                        phi = EMPTY_DOUBLE;

                    };
                } position;

                class launchangles {
                  public:

                    double alpha;

                    double beta;
                     launchangles() {
                        alpha = EMPTY_DOUBLE;
                        beta = EMPTY_DOUBLE;

                    };
                } launchangles;

                class beam {
                  public:

                    class spot {
                      public:

                        Array < double, 1 > size;

                        double angle;
                         spot() {
                            angle = EMPTY_DOUBLE;

                        };
                    } spot;

                    class phaseellipse {
                      public:

                        Array < double, 1 > invcurvrad;

                        double angle;
                         phaseellipse() {
                            angle = EMPTY_DOUBLE;

                        };
                    } phaseellipse;
                    beam() {

                    };
                } beam;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                antenna_ec() {
                    frequency = EMPTY_DOUBLE;
                    mode = EMPTY_INT;

                };
            };
            Array < class antenna_ec, 1 > antenna_ec;

            class antenna_ic {
              public:

                std::string name;

                class frequency {
                  public:

                    double value;

                    double abserror;

                    double relerror;
                     frequency() {
                        value = EMPTY_DOUBLE;
                        abserror = EMPTY_DOUBLE;
                        relerror = EMPTY_DOUBLE;

                    };
                } frequency;

                class power {
                  public:

                    double value;

                    double abserror;

                    double relerror;
                     power() {
                        value = EMPTY_DOUBLE;
                        abserror = EMPTY_DOUBLE;
                        relerror = EMPTY_DOUBLE;

                    };
                } power;

                class setup {
                  public:

                    class straps {
                      public:

                        class phase {
                          public:

                            double value;

                            double abserror;

                            double relerror;
                             phase() {
                                value = EMPTY_DOUBLE;
                                abserror = EMPTY_DOUBLE;
                                relerror = EMPTY_DOUBLE;

                            };
                        } phase;

                        double phi_centre;

                        double width;

                        double dist2wall;

                        class coord_strap {
                          public:

                            Array < double, 1 > r;

                             Array < double, 1 > z;
                             coord_strap() {

                            };
                        } coord_strap;
                        straps() {
                            phi_centre = EMPTY_DOUBLE;
                            width = EMPTY_DOUBLE;
                            dist2wall = EMPTY_DOUBLE;

                        };
                    };
                    Array < class straps, 1 > straps;
                    setup() {

                    };
                } setup;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                antenna_ic() {

                };
            };
            Array < class antenna_ic, 1 > antenna_ic;

            class antenna_lh {
              public:

                std::string name;

                double frequency;

                class power {
                  public:

                    double value;

                    double abserror;

                    double relerror;
                     power() {
                        value = EMPTY_DOUBLE;
                        abserror = EMPTY_DOUBLE;
                        relerror = EMPTY_DOUBLE;

                    };
                } power;

                double n_par;

                class position {
                  public:

                    double r;

                    double z;

                    double phi;
                     position() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;
                        phi = EMPTY_DOUBLE;

                    };
                } position;

                class setup {
                  public:

                    class modules {
                      public:

                        int nma_theta;

                        int nma_phi;

                         Array < int, 1 > ima_theta;

                         Array < int, 1 > ima_phi;

                        double sm_theta;

                        class amplitude {
                          public:

                            Array < double, 1 > value;

                             Array < double, 1 > abserror;

                             Array < double, 1 > relerror;
                             amplitude() {

                            };
                        } amplitude;

                        class phase {
                          public:

                            Array < double, 1 > value;

                             Array < double, 1 > abserror;

                             Array < double, 1 > relerror;
                             phase() {

                            };
                        } phase;

                        class waveguides {
                          public:

                            int nwm_theta;

                            int nwm_phi;

                             Array < int, 1 > mask;

                            int npwbm_phi;

                            int npwe_phi;

                            double sw_theta;

                            double hw_theta;

                            double bwa;

                            double biwp;

                            double bewp;

                             Array < double, 1 > e_phi;

                             Array < double, 1 > scl;
                             waveguides() {
                                nwm_theta = EMPTY_INT;
                                nwm_phi = EMPTY_INT;
                                npwbm_phi = EMPTY_INT;
                                npwe_phi = EMPTY_INT;
                                sw_theta = EMPTY_DOUBLE;
                                hw_theta = EMPTY_DOUBLE;
                                bwa = EMPTY_DOUBLE;
                                biwp = EMPTY_DOUBLE;
                                bewp = EMPTY_DOUBLE;

                            };
                        } waveguides;
                        modules() {
                            nma_theta = EMPTY_INT;
                            nma_phi = EMPTY_INT;
                            sm_theta = EMPTY_DOUBLE;

                        };
                    } modules;
                    setup() {

                    };
                } setup;

                class plasmaedge {
                  public:

                    int npoints;

                     Array < double, 1 > distance;

                     Array < double, 1 > density;
                     plasmaedge() {
                        npoints = EMPTY_INT;

                    };
                } plasmaedge;

                class beam {
                  public:

                    class spot {
                      public:

                        Array < double, 1 > size;

                        double angle;
                         spot() {
                            angle = EMPTY_DOUBLE;

                        };
                    } spot;

                    class phaseellipse {
                      public:

                        Array < double, 1 > invcurvrad;

                        double angle;
                         phaseellipse() {
                            angle = EMPTY_DOUBLE;

                        };
                    } phaseellipse;
                    beam() {

                    };
                } beam;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                antenna_lh() {
                    frequency = EMPTY_DOUBLE;
                    n_par = EMPTY_DOUBLE;

                };
            };
            Array < class antenna_lh, 1 > antenna_lh;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            antennas & operator()(int index) {
                return array(index);
            };
            antennas & operator[](int index) {
                return array(index);
            };
            int extent(int dim = 0) {
                return array.extent(dim);
            };
        };

        class compositionc:Cpo {
          private:
            int expIdx;
            bool connected;
          public:

             class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class compositions {
              public:

                class nuclei {
                  public:

                    double zn;

                    double amn;

                     std::string label;
                     nuclei() {
                        zn = EMPTY_DOUBLE;
                        amn = EMPTY_DOUBLE;

                    };
                };
                Array < class nuclei, 1 > nuclei;

                class ions {
                  public:

                    int nucindex;

                    double zion;

                    int imp_flag;

                     std::string label;
                     ions() {
                        nucindex = EMPTY_INT;
                        zion = EMPTY_DOUBLE;
                        imp_flag = EMPTY_INT;

                    };
                };
                Array < class ions, 1 > ions;

                class impurities {
                  public:

                    int nucindex;

                    int i_ion;

                    int nzimp;

                     Array < double, 1 > zmin;

                     Array < double, 1 > zmax;

                     Array < std::string, 1 > label;
                     impurities() {
                        nucindex = EMPTY_INT;
                        i_ion = EMPTY_INT;
                        nzimp = EMPTY_INT;

                    };
                };
                Array < class impurities, 1 > impurities;

                class neutralscomp {
                  public:

                    class neutcomp {
                      public:

                        int nucindex;

                        int multiplicity;
                         neutcomp() {
                            nucindex = EMPTY_INT;
                            multiplicity = EMPTY_INT;

                        };
                    };
                    Array < class neutcomp, 1 > neutcomp;

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    };
                    Array < class type, 1 > type;

                    std::string label;
                    neutralscomp() {

                    };
                };
                Array < class neutralscomp, 1 > neutralscomp;

                class edgespecies {
                  public:

                    int nucindex;

                    double zmin;

                    double zmax;

                     std::string label;
                     edgespecies() {
                        nucindex = EMPTY_INT;
                        zmin = EMPTY_DOUBLE;
                        zmax = EMPTY_DOUBLE;

                    };
                };
                Array < class edgespecies, 1 > edgespecies;

                class signature {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     signature() {
                        flag = EMPTY_INT;

                    };
                } signature;
                compositions() {

                };
            } compositions;
            compositionc();
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            }
            int get();
            int get(int idx);
            int put();
            int put(int idx);
            void flush();
            void flush(int idx);
            void discard();
            void discard(int idx);
            friend ostream & operator <<(ostream & os, const compositionc & obj);

        };

        class coredelta:Cpo {
          private:
            int expIdx;
            bool connected;
          public:
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class composition {
              public:

                Array < double, 1 > amn;

                 Array < double, 1 > zn;

                 Array < double, 1 > zion;

                 Array < int, 1 > imp_flag;

                 Array < std::string, 1 > label;
                 composition() {

                };
            } composition;

            class desc_impur {
              public:

                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;

                 Array < std::string, 1 > label;
                 desc_impur() {

                };
            } desc_impur;

            class compositions {
              public:

                class nuclei {
                  public:

                    double zn;

                    double amn;

                     std::string label;
                     nuclei() {
                        zn = EMPTY_DOUBLE;
                        amn = EMPTY_DOUBLE;

                    };
                };
                Array < class nuclei, 1 > nuclei;

                class ions {
                  public:

                    int nucindex;

                    double zion;

                    int imp_flag;

                     std::string label;
                     ions() {
                        nucindex = EMPTY_INT;
                        zion = EMPTY_DOUBLE;
                        imp_flag = EMPTY_INT;

                    };
                };
                Array < class ions, 1 > ions;

                class impurities {
                  public:

                    int nucindex;

                    int i_ion;

                    int nzimp;

                     Array < double, 1 > zmin;

                     Array < double, 1 > zmax;

                     Array < std::string, 1 > label;
                     impurities() {
                        nucindex = EMPTY_INT;
                        i_ion = EMPTY_INT;
                        nzimp = EMPTY_INT;

                    };
                };
                Array < class impurities, 1 > impurities;

                class neutralscomp {
                  public:

                    class neutcomp {
                      public:

                        int nucindex;

                        int multiplicity;
                         neutcomp() {
                            nucindex = EMPTY_INT;
                            multiplicity = EMPTY_INT;

                        };
                    };
                    Array < class neutcomp, 1 > neutcomp;

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    };
                    Array < class type, 1 > type;

                    std::string label;
                    neutralscomp() {

                    };
                };
                Array < class neutralscomp, 1 > neutralscomp;

                class edgespecies {
                  public:

                    int nucindex;

                    double zmin;

                    double zmax;

                     std::string label;
                     edgespecies() {
                        nucindex = EMPTY_INT;
                        zmin = EMPTY_DOUBLE;
                        zmax = EMPTY_DOUBLE;

                    };
                };
                Array < class edgespecies, 1 > edgespecies;

                class signature {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     signature() {
                        flag = EMPTY_INT;

                    };
                } signature;
                compositions() {

                };
            } compositions;

            class values {
              public:

                class deltaid {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     deltaid() {
                        flag = EMPTY_INT;

                    };
                } deltaid;

                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;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                values() {

                };
            };
            Array < class values, 1 > values;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            coredelta & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            Array < double, 1 > rho_tor;

            Array < double, 1 > rho_tor_norm;

            class neutcompo {
              public:

                class atomlist {
                  public:

                    double amn;

                    double zn;

                    class ionimptype {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         ionimptype() {
                            flag = EMPTY_INT;

                        };
                    } ionimptype;

                    int ionimpindex;
                    atomlist() {
                        amn = EMPTY_DOUBLE;
                        zn = EMPTY_DOUBLE;
                        ionimpindex = EMPTY_INT;

                    };
                };
                Array < class atomlist, 1 > atomlist;

                class neutral {
                  public:

                    class neutcomp {
                      public:

                        int nucindex;

                        int multiplicity;
                         neutcomp() {
                            nucindex = EMPTY_INT;
                            multiplicity = EMPTY_INT;

                        };
                    };
                    Array < class neutcomp, 1 > neutcomp;

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    };
                    Array < class type, 1 > type;

                    std::string label;
                    neutral() {

                    };
                };
                Array < class neutral, 1 > neutral;
                neutcompo() {

                };
            } neutcompo;

            class composition {
              public:

                Array < double, 1 > amn;

                 Array < double, 1 > zn;

                 Array < double, 1 > zion;

                 Array < int, 1 > imp_flag;

                 Array < std::string, 1 > label;
                 composition() {

                };
            } composition;

            class desc_impur {
              public:

                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;

                 Array < std::string, 1 > label;
                 desc_impur() {

                };
            } desc_impur;

            class compositions {
              public:

                class nuclei {
                  public:

                    double zn;

                    double amn;

                     std::string label;
                     nuclei() {
                        zn = EMPTY_DOUBLE;
                        amn = EMPTY_DOUBLE;

                    };
                };
                Array < class nuclei, 1 > nuclei;

                class ions {
                  public:

                    int nucindex;

                    double zion;

                    int imp_flag;

                     std::string label;
                     ions() {
                        nucindex = EMPTY_INT;
                        zion = EMPTY_DOUBLE;
                        imp_flag = EMPTY_INT;

                    };
                };
                Array < class ions, 1 > ions;

                class impurities {
                  public:

                    int nucindex;

                    int i_ion;

                    int nzimp;

                     Array < double, 1 > zmin;

                     Array < double, 1 > zmax;

                     Array < std::string, 1 > label;
                     impurities() {
                        nucindex = EMPTY_INT;
                        i_ion = EMPTY_INT;
                        nzimp = EMPTY_INT;

                    };
                };
                Array < class impurities, 1 > impurities;

                class neutralscomp {
                  public:

                    class neutcomp {
                      public:

                        int nucindex;

                        int multiplicity;
                         neutcomp() {
                            nucindex = EMPTY_INT;
                            multiplicity = EMPTY_INT;

                        };
                    };
                    Array < class neutcomp, 1 > neutcomp;

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    };
                    Array < class type, 1 > type;

                    std::string label;
                    neutralscomp() {

                    };
                };
                Array < class neutralscomp, 1 > neutralscomp;

                class edgespecies {
                  public:

                    int nucindex;

                    double zmin;

                    double zmax;

                     std::string label;
                     edgespecies() {
                        nucindex = EMPTY_INT;
                        zmin = EMPTY_DOUBLE;
                        zmax = EMPTY_DOUBLE;

                    };
                };
                Array < class edgespecies, 1 > edgespecies;

                class signature {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     signature() {
                        flag = EMPTY_INT;

                    };
                } signature;
                compositions() {

                };
            } compositions;

            class profiles {
              public:

                class neutraltype {
                  public:

                    class n0 {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > flux;

                        class boundary {
                          public:

                            Array < double, 1 > value;

                            int type;

                            double rho_tor;
                             boundary() {
                                type = EMPTY_INT;
                                rho_tor = EMPTY_DOUBLE;

                            };
                        } boundary;
                        n0() {

                        };
                    } n0;

                    class t0 {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > flux;

                        class boundary {
                          public:

                            Array < double, 1 > value;

                            int type;

                            double rho_tor;
                             boundary() {
                                type = EMPTY_INT;
                                rho_tor = EMPTY_DOUBLE;

                            };
                        } boundary;
                        t0() {

                        };
                    } t0;

                    class v0 {
                      public:

                        class toroidal {
                          public:

                            Array < double, 1 > value;

                            class boundary {
                              public:

                                Array < double, 1 > value;

                                int type;

                                double rho_tor;
                                 boundary() {
                                    type = EMPTY_INT;
                                    rho_tor = EMPTY_DOUBLE;

                                };
                            } boundary;
                            toroidal() {

                            };
                        } toroidal;

                        class poloidal {
                          public:

                            Array < double, 1 > value;

                            class boundary {
                              public:

                                Array < double, 1 > value;

                                int type;

                                double rho_tor;
                                 boundary() {
                                    type = EMPTY_INT;
                                    rho_tor = EMPTY_DOUBLE;

                                };
                            } boundary;
                            poloidal() {

                            };
                        } poloidal;

                        class radial {
                          public:

                            Array < double, 1 > value;

                            class boundary {
                              public:

                                Array < double, 1 > value;

                                int type;

                                double rho_tor;
                                 boundary() {
                                    type = EMPTY_INT;
                                    rho_tor = EMPTY_DOUBLE;

                                };
                            } boundary;
                            radial() {

                            };
                        } radial;
                        v0() {

                        };
                    } v0;
                    neutraltype() {

                    };
                };
                Array < class neutraltype, 1 > neutraltype;

                Array < double, 1 > prad0;
                profiles() {

                };
            };
            Array < class profiles, 1 > profiles;

            class ioncoeff {
              public:

                class recycling {
                  public:

                    Array < double, 1 > particles;

                     Array < double, 1 > energy;
                     recycling() {

                    };
                } recycling;

                class sputtering {
                  public:

                    Array < double, 1 > physical;

                     Array < double, 1 > chemical;
                     sputtering() {

                    };
                } sputtering;
                ioncoeff() {

                };
            };
            Array < class ioncoeff, 1 > ioncoeff;

            class impcoeff {
              public:

                class chargestate {
                  public:

                    class recycling {
                      public:

                        Array < double, 1 > particles;

                         Array < double, 1 > energy;
                         recycling() {

                        };
                    } recycling;

                    class sputtering {
                      public:

                        Array < double, 1 > physical;

                         Array < double, 1 > chemical;
                         sputtering() {

                        };
                    } sputtering;
                    chargestate() {

                    };
                };
                Array < class chargestate, 1 > chargestate;
                impcoeff() {

                };
            };
            Array < class impcoeff, 1 > impcoeff;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            coreneutrals & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            Array < double, 1 > rho_tor_norm;

            Array < double, 1 > rho_tor;

            Array < std::string, 1 > source;

            Array < int, 1 > flag;

            class desc_impur {
              public:

                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;

                 Array < std::string, 1 > label;
                 desc_impur() {

                };
            } desc_impur;

            class compositions {
              public:

                class nuclei {
                  public:

                    double zn;

                    double amn;

                     std::string label;
                     nuclei() {
                        zn = EMPTY_DOUBLE;
                        amn = EMPTY_DOUBLE;

                    };
                };
                Array < class nuclei, 1 > nuclei;

                class ions {
                  public:

                    int nucindex;

                    double zion;

                    int imp_flag;

                     std::string label;
                     ions() {
                        nucindex = EMPTY_INT;
                        zion = EMPTY_DOUBLE;
                        imp_flag = EMPTY_INT;

                    };
                };
                Array < class ions, 1 > ions;

                class impurities {
                  public:

                    int nucindex;

                    int i_ion;

                    int nzimp;

                     Array < double, 1 > zmin;

                     Array < double, 1 > zmax;

                     Array < std::string, 1 > label;
                     impurities() {
                        nucindex = EMPTY_INT;
                        i_ion = EMPTY_INT;
                        nzimp = EMPTY_INT;

                    };
                };
                Array < class impurities, 1 > impurities;

                class neutralscomp {
                  public:

                    class neutcomp {
                      public:

                        int nucindex;

                        int multiplicity;
                         neutcomp() {
                            nucindex = EMPTY_INT;
                            multiplicity = EMPTY_INT;

                        };
                    };
                    Array < class neutcomp, 1 > neutcomp;

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    };
                    Array < class type, 1 > type;

                    std::string label;
                    neutralscomp() {

                    };
                };
                Array < class neutralscomp, 1 > neutralscomp;

                class edgespecies {
                  public:

                    int nucindex;

                    double zmin;

                    double zmax;

                     std::string label;
                     edgespecies() {
                        nucindex = EMPTY_INT;
                        zmin = EMPTY_DOUBLE;
                        zmax = EMPTY_DOUBLE;

                    };
                };
                Array < class edgespecies, 1 > edgespecies;

                class signature {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     signature() {
                        flag = EMPTY_INT;

                    };
                } signature;
                compositions() {

                };
            } compositions;

            Array < std::string, 1 > atomic_data;

            class impurity {
              public:

                Array < double, 2 > z;

                 Array < double, 2 > zsq;

                 Array < double, 2 > nz;

                class source_term {
                  public:

                    Array < double, 2 > value;

                     Array < double, 2 > integral;

                     Array < std::string, 1 > source;
                     source_term() {

                    };
                } source_term;

                class boundary {
                  public:

                    Array < double, 2 > value;

                     std::string source;

                     Array < int, 1 > type;

                     Array < double, 1 > rho;

                    class codeparam {
                      public:

                        std::string codename;

                        std::string codeversion;

                        std::string parameters;

                        std::string output_diag;

                        int output_flag;
                         codeparam() {
                            output_flag = EMPTY_INT;

                        };
                    } codeparam;
                    boundary() {

                    };
                } boundary;

                class transp_coef {
                  public:

                    Array < double, 2 > diff;

                     Array < double, 2 > vconv;

                     Array < std::string, 1 > source;
                     transp_coef() {

                    };
                } transp_coef;

                class flux {
                  public:

                    Array < double, 2 > flux_dv;

                     Array < double, 2 > flux_interp;
                     flux() {

                    };
                } flux;

                Array < double, 2 > time_deriv;

                class diagnostic {
                  public:

                    class radiation {
                      public:

                        class line_rad {
                          public:

                            Array < double, 2 > profile;

                             Array < double, 2 > integral;
                             line_rad() {

                            };
                        } line_rad;

                        class brem_radrec {
                          public:

                            Array < double, 2 > profile;

                             Array < double, 2 > integral;
                             brem_radrec() {

                            };
                        } brem_radrec;

                        class sum {
                          public:

                            Array < double, 2 > profile;

                             Array < double, 2 > integral;
                             sum() {

                            };
                        } sum;
                        radiation() {

                        };
                    } radiation;

                    class energy {
                      public:

                        class ionization {
                          public:

                            Array < double, 2 > profile;

                             Array < double, 2 > integral;
                             ionization() {

                            };
                        } ionization;

                        class recombin {
                          public:

                            Array < double, 2 > profile;

                             Array < double, 2 > integral;
                             recombin() {

                            };
                        } recombin;

                        class sum {
                          public:

                            Array < double, 2 > profile;

                             Array < double, 2 > integral;
                             sum() {

                            };
                        } sum;
                        energy() {

                        };
                    } energy;
                    diagnostic() {

                    };
                } diagnostic;
                impurity() {

                };
            };
            Array < class impurity, 1 > impurity;

            class diagnostic {
              public:

                class radiation {
                  public:

                    class line_rad {
                      public:

                        Array < double, 2 > profile;

                         Array < double, 2 > integral;
                         line_rad() {

                        };
                    } line_rad;

                    class brem_radrec {
                      public:

                        Array < double, 2 > profile;

                         Array < double, 2 > integral;
                         brem_radrec() {

                        };
                    } brem_radrec;

                    class sum {
                      public:

                        Array < double, 2 > profile;

                         Array < double, 2 > integral;
                         sum() {

                        };
                    } sum;
                    radiation() {

                    };
                } radiation;

                class energy {
                  public:

                    class ionization {
                      public:

                        Array < double, 2 > profile;

                         Array < double, 2 > integral;
                         ionization() {

                        };
                    } ionization;

                    class recombin {
                      public:

                        Array < double, 2 > profile;

                         Array < double, 2 > integral;
                         recombin() {

                        };
                    } recombin;

                    class sum {
                      public:

                        Array < double, 2 > profile;

                         Array < double, 2 > integral;
                         sum() {

                        };
                    } sum;
                    energy() {

                    };
                } energy;
                diagnostic() {

                };
            } diagnostic;

            class diagnosticsum {
              public:

                class radiation {
                  public:

                    class line_rad {
                      public:

                        Array < double, 1 > profile;

                         Array < double, 1 > integral;
                         line_rad() {

                        };
                    } line_rad;

                    class brem_radrec {
                      public:

                        Array < double, 1 > profile;

                         Array < double, 1 > integral;
                         brem_radrec() {

                        };
                    } brem_radrec;

                    class sum {
                      public:

                        Array < double, 1 > profile;

                         Array < double, 1 > integral;
                         sum() {

                        };
                    } sum;
                    radiation() {

                    };
                } radiation;

                class energy {
                  public:

                    class ionization {
                      public:

                        Array < double, 1 > profile;

                         Array < double, 1 > integral;
                         ionization() {

                        };
                    } ionization;

                    class recombin {
                      public:

                        Array < double, 1 > profile;

                         Array < double, 1 > integral;
                         recombin() {

                        };
                    } recombin;

                    class sum {
                      public:

                        Array < double, 1 > profile;

                         Array < double, 1 > integral;
                         sum() {

                        };
                    } sum;
                    energy() {

                    };
                } energy;
                diagnosticsum() {

                };
            } diagnosticsum;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } codeparam;

            double time;
            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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            coreimpur & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            Array < double, 1 > rho_tor_norm;

            Array < double, 1 > rho_tor;

            Array < double, 1 > drho_dt;

            class toroid_field {
              public:

                double b0;

                double b0prime;

                double r0;

                double time;
                 toroid_field() {
                    b0 = EMPTY_DOUBLE;
                    b0prime = EMPTY_DOUBLE;
                    r0 = EMPTY_DOUBLE;
                    time = EMPTY_DOUBLE;

                };
            } toroid_field;

            class composition {
              public:

                Array < double, 1 > amn;

                 Array < double, 1 > zn;

                 Array < double, 1 > zion;

                 Array < int, 1 > imp_flag;

                 Array < std::string, 1 > label;
                 composition() {

                };
            } composition;

            class desc_impur {
              public:

                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;

                 Array < std::string, 1 > label;
                 desc_impur() {

                };
            } desc_impur;

            class compositions {
              public:

                class nuclei {
                  public:

                    double zn;

                    double amn;

                     std::string label;
                     nuclei() {
                        zn = EMPTY_DOUBLE;
                        amn = EMPTY_DOUBLE;

                    };
                };
                Array < class nuclei, 1 > nuclei;

                class ions {
                  public:

                    int nucindex;

                    double zion;

                    int imp_flag;

                     std::string label;
                     ions() {
                        nucindex = EMPTY_INT;
                        zion = EMPTY_DOUBLE;
                        imp_flag = EMPTY_INT;

                    };
                };
                Array < class ions, 1 > ions;

                class impurities {
                  public:

                    int nucindex;

                    int i_ion;

                    int nzimp;

                     Array < double, 1 > zmin;

                     Array < double, 1 > zmax;

                     Array < std::string, 1 > label;
                     impurities() {
                        nucindex = EMPTY_INT;
                        i_ion = EMPTY_INT;
                        nzimp = EMPTY_INT;

                    };
                };
                Array < class impurities, 1 > impurities;

                class neutralscomp {
                  public:

                    class neutcomp {
                      public:

                        int nucindex;

                        int multiplicity;
                         neutcomp() {
                            nucindex = EMPTY_INT;
                            multiplicity = EMPTY_INT;

                        };
                    };
                    Array < class neutcomp, 1 > neutcomp;

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    };
                    Array < class type, 1 > type;

                    std::string label;
                    neutralscomp() {

                    };
                };
                Array < class neutralscomp, 1 > neutralscomp;

                class edgespecies {
                  public:

                    int nucindex;

                    double zmin;

                    double zmax;

                     std::string label;
                     edgespecies() {
                        nucindex = EMPTY_INT;
                        zmin = EMPTY_DOUBLE;
                        zmax = EMPTY_DOUBLE;

                    };
                };
                Array < class edgespecies, 1 > edgespecies;

                class signature {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     signature() {
                        flag = EMPTY_INT;

                    };
                } signature;
                compositions() {

                };
            } compositions;

            class psi {
              public:

                Array < double, 1 > value;

                 Array < double, 1 > ddrho;

                 Array < double, 1 > d2drho2;

                 Array < double, 1 > ddt_rhotorn;

                 Array < double, 1 > ddt_phi;

                 std::string source;

                int flag;

                class boundary {
                  public:

                    Array < double, 1 > value;

                     std::string source;

                    int type;

                    double rho;

                    class codeparam {
                      public:

                        std::string codename;

                        std::string codeversion;

                        std::string parameters;

                        std::string output_diag;

                        int output_flag;
                         codeparam() {
                            output_flag = EMPTY_INT;

                        };
                    } codeparam;
                     boundary() {
                        type = EMPTY_INT;
                        rho = EMPTY_DOUBLE;

                    };
                } boundary;

                class jni {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > integral;

                     std::string source;
                     jni() {

                    };
                } jni;

                class sigma_par {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     sigma_par() {

                    };
                } sigma_par;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                psi() {
                    flag = EMPTY_INT;

                };
            } psi;

            class te {
              public:

                Array < double, 1 > value;

                 Array < double, 1 > ddrho;

                 Array < double, 1 > d2drho2;

                 Array < double, 1 > ddt;

                 std::string source;

                int flag;

                class boundary {
                  public:

                    Array < double, 1 > value;

                     std::string source;

                    int type;

                    double rho_tor;
                     boundary() {
                        type = EMPTY_INT;
                        rho_tor = EMPTY_DOUBLE;

                    };
                } boundary;

                class source_term {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > integral;

                     std::string source;
                     source_term() {

                    };
                } source_term;

                class transp_coef {
                  public:

                    Array < double, 1 > diff;

                     Array < double, 1 > vconv;

                     std::string source;
                     transp_coef() {

                    };
                } transp_coef;

                class flux {
                  public:

                    Array < double, 1 > flux_dv;

                     Array < double, 1 > flux_interp;
                     flux() {

                    };
                } flux;

                Array < double, 1 > flux_dv_surf;

                Array < double, 1 > time_deriv;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                te() {
                    flag = EMPTY_INT;

                };
            } te;

            class ti {
              public:

                Array < double, 2 > value;

                 Array < double, 2 > ddrho;

                 Array < double, 2 > d2drho2;

                 Array < double, 2 > ddt;

                 Array < std::string, 1 > source;

                 Array < int, 1 > flag;

                class boundary {
                  public:

                    Array < double, 2 > value;

                     Array < std::string, 1 > source;

                     Array < int, 1 > type;

                     Array < double, 1 > rho_tor;
                     boundary() {

                    };
                } boundary;

                class source_term {
                  public:

                    Array < double, 2 > value;

                     Array < double, 2 > integral;

                     Array < std::string, 1 > source;
                     source_term() {

                    };
                } source_term;

                class transp_coef {
                  public:

                    Array < double, 2 > diff;

                     Array < double, 2 > vconv;

                     Array < std::string, 1 > source;
                     transp_coef() {

                    };
                } transp_coef;

                class flux {
                  public:

                    Array < double, 2 > flux_dv;

                     Array < double, 2 > flux_interp;
                     flux() {

                    };
                } flux;

                Array < double, 2 > flux_dv_surf;

                Array < double, 2 > time_deriv;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                ti() {

                };
            } ti;

            class ne {
              public:

                Array < double, 1 > value;

                 Array < double, 1 > ddrho;

                 Array < double, 1 > d2drho2;

                 Array < double, 1 > ddt;

                 std::string source;

                int flag;

                class boundary {
                  public:

                    Array < double, 1 > value;

                     std::string source;

                    int type;

                    double rho_tor;
                     boundary() {
                        type = EMPTY_INT;
                        rho_tor = EMPTY_DOUBLE;

                    };
                } boundary;

                class source_term {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > integral;

                     std::string source;
                     source_term() {

                    };
                } source_term;

                class transp_coef {
                  public:

                    Array < double, 1 > diff;

                     Array < double, 1 > vconv;

                     std::string source;
                     transp_coef() {

                    };
                } transp_coef;

                class flux {
                  public:

                    Array < double, 1 > flux_dv;

                     Array < double, 1 > flux_interp;
                     flux() {

                    };
                } flux;

                Array < double, 1 > flux_dv_surf;

                Array < double, 1 > time_deriv;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                ne() {
                    flag = EMPTY_INT;

                };
            } ne;

            class ni {
              public:

                Array < double, 2 > value;

                 Array < double, 2 > ddrho;

                 Array < double, 2 > d2drho2;

                 Array < double, 2 > ddt;

                 Array < std::string, 1 > source;

                 Array < int, 1 > flag;

                class boundary {
                  public:

                    Array < double, 2 > value;

                     Array < std::string, 1 > source;

                     Array < int, 1 > type;

                     Array < double, 1 > rho_tor;
                     boundary() {

                    };
                } boundary;

                class source_term {
                  public:

                    Array < double, 2 > value;

                     Array < double, 2 > integral;

                     Array < std::string, 1 > source;
                     source_term() {

                    };
                } source_term;

                class transp_coef {
                  public:

                    Array < double, 2 > diff;

                     Array < double, 2 > vconv;

                     Array < std::string, 1 > source;
                     transp_coef() {

                    };
                } transp_coef;

                class flux {
                  public:

                    Array < double, 2 > flux_dv;

                     Array < double, 2 > flux_interp;
                     flux() {

                    };
                } flux;

                Array < double, 2 > flux_dv_surf;

                Array < double, 2 > time_deriv;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                ni() {

                };
            } ni;

            class vtor {
              public:

                Array < double, 2 > value;

                 Array < double, 2 > ddrho;

                 Array < double, 2 > d2drho2;

                 Array < double, 2 > ddt;

                 Array < std::string, 1 > source;

                 Array < int, 1 > flag;

                class boundary {
                  public:

                    Array < double, 2 > value;

                     Array < std::string, 1 > source;

                     Array < int, 1 > type;

                     Array < double, 1 > rho_tor;
                     boundary() {

                    };
                } boundary;

                class source_term {
                  public:

                    Array < double, 2 > value;

                     Array < double, 2 > integral;

                     Array < std::string, 1 > source;
                     source_term() {

                    };
                } source_term;

                class transp_coef {
                  public:

                    Array < double, 2 > diff;

                     Array < double, 2 > vconv;

                     Array < std::string, 1 > source;
                     transp_coef() {

                    };
                } transp_coef;

                class flux {
                  public:

                    Array < double, 2 > flux_dv;

                     Array < double, 2 > flux_interp;
                     flux() {

                    };
                } flux;

                Array < double, 2 > flux_dv_surf;

                Array < double, 2 > time_deriv;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                vtor() {

                };
            } vtor;

            class profiles1d {
              public:

                class pe {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     pe() {

                    };
                } pe;

                class dpedt {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     dpedt() {

                    };
                } dpedt;

                class pi {
                  public:

                    Array < double, 2 > value;

                     Array < std::string, 1 > source;
                     pi() {

                    };
                } pi;

                class pi_tot {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     pi_tot() {

                    };
                } pi_tot;

                class dpi_totdt {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     dpi_totdt() {

                    };
                } dpi_totdt;

                class pr_th {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     pr_th() {

                    };
                } pr_th;

                class pr_perp {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     pr_perp() {

                    };
                } pr_perp;

                class pr_parallel {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     pr_parallel() {

                    };
                } pr_parallel;

                class jtot {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     jtot() {

                    };
                } jtot;

                class jni {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     jni() {

                    };
                } jni;

                class jphi {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     jphi() {

                    };
                } jphi;

                class joh {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     joh() {

                    };
                } joh;

                class vloop {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     vloop() {

                    };
                } vloop;

                class sigmapar {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     sigmapar() {

                    };
                } sigmapar;

                class qoh {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > integral;

                     std::string source;
                     qoh() {

                    };
                } qoh;

                class qei {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     qei() {

                    };
                } qei;

                class eparallel {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     eparallel() {

                    };
                } eparallel;

                class e_b {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     e_b() {

                    };
                } e_b;

                class q {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     q() {

                    };
                } q;

                class shear {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     shear() {

                    };
                } shear;

                class ns {
                  public:

                    Array < double, 2 > value;

                     Array < std::string, 1 > source;
                     ns() {

                    };
                } ns;

                class mtor {
                  public:

                    Array < double, 2 > value;

                     Array < std::string, 1 > source;
                     mtor() {

                    };
                } mtor;

                class wtor {
                  public:

                    Array < double, 2 > value;

                     Array < std::string, 1 > source;
                     wtor() {

                    };
                } wtor;

                class zeff {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     zeff() {

                    };
                } zeff;

                class bpol {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     bpol() {

                    };
                } bpol;

                class dvprimedt {
                  public:

                    Array < double, 1 > value;

                     std::string source;
                     dvprimedt() {

                    };
                } dvprimedt;
                profiles1d() {

                };
            } profiles1d;

            class globalparam {
              public:

                double current_tot;

                double current_bnd;

                double current_ni;

                double vloop;

                double li;

                double beta_tor;

                double beta_normal;

                double beta_pol;

                double w_dia;
                 globalparam() {
                    current_tot = EMPTY_DOUBLE;
                    current_bnd = EMPTY_DOUBLE;
                    current_ni = EMPTY_DOUBLE;
                    vloop = EMPTY_DOUBLE;
                    li = EMPTY_DOUBLE;
                    beta_tor = EMPTY_DOUBLE;
                    beta_normal = EMPTY_DOUBLE;
                    beta_pol = EMPTY_DOUBLE;
                    w_dia = EMPTY_DOUBLE;

                };
            } globalparam;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            coreprof & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class composition {
              public:

                Array < double, 1 > amn;

                 Array < double, 1 > zn;

                 Array < double, 1 > zion;

                 Array < int, 1 > imp_flag;

                 Array < std::string, 1 > label;
                 composition() {

                };
            } composition;

            class desc_impur {
              public:

                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;

                 Array < std::string, 1 > label;
                 desc_impur() {

                };
            } desc_impur;

            class compositions {
              public:

                class nuclei {
                  public:

                    double zn;

                    double amn;

                     std::string label;
                     nuclei() {
                        zn = EMPTY_DOUBLE;
                        amn = EMPTY_DOUBLE;

                    };
                };
                Array < class nuclei, 1 > nuclei;

                class ions {
                  public:

                    int nucindex;

                    double zion;

                    int imp_flag;

                     std::string label;
                     ions() {
                        nucindex = EMPTY_INT;
                        zion = EMPTY_DOUBLE;
                        imp_flag = EMPTY_INT;

                    };
                };
                Array < class ions, 1 > ions;

                class impurities {
                  public:

                    int nucindex;

                    int i_ion;

                    int nzimp;

                     Array < double, 1 > zmin;

                     Array < double, 1 > zmax;

                     Array < std::string, 1 > label;
                     impurities() {
                        nucindex = EMPTY_INT;
                        i_ion = EMPTY_INT;
                        nzimp = EMPTY_INT;

                    };
                };
                Array < class impurities, 1 > impurities;

                class neutralscomp {
                  public:

                    class neutcomp {
                      public:

                        int nucindex;

                        int multiplicity;
                         neutcomp() {
                            nucindex = EMPTY_INT;
                            multiplicity = EMPTY_INT;

                        };
                    };
                    Array < class neutcomp, 1 > neutcomp;

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    };
                    Array < class type, 1 > type;

                    std::string label;
                    neutralscomp() {

                    };
                };
                Array < class neutralscomp, 1 > neutralscomp;

                class edgespecies {
                  public:

                    int nucindex;

                    double zmin;

                    double zmax;

                     std::string label;
                     edgespecies() {
                        nucindex = EMPTY_INT;
                        zmin = EMPTY_DOUBLE;
                        zmax = EMPTY_DOUBLE;

                    };
                };
                Array < class edgespecies, 1 > edgespecies;

                class signature {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     signature() {
                        flag = EMPTY_INT;

                    };
                } signature;
                compositions() {

                };
            } compositions;

            class toroid_field {
              public:

                double r0;

                double b0;
                 toroid_field() {
                    r0 = EMPTY_DOUBLE;
                    b0 = EMPTY_DOUBLE;

                };
            } toroid_field;

            class values {
              public:

                class sourceid {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     sourceid() {
                        flag = EMPTY_INT;

                    };
                } sourceid;

                Array < double, 1 > rho_tor;

                Array < double, 1 > rho_tor_norm;

                Array < double, 1 > j;

                Array < double, 1 > sigma;

                class si {
                  public:

                    Array < double, 2 > exp;

                     Array < double, 2 > imp;
                     si() {

                    };
                } si;

                class se {
                  public:

                    Array < double, 1 > exp;

                     Array < double, 1 > imp;
                     se() {

                    };
                } se;

                class sz {
                  public:

                    Array < double, 2 > exp;

                     Array < double, 2 > imp;
                     sz() {

                    };
                };
                Array < class sz, 1 > sz;

                class qi {
                  public:

                    Array < double, 2 > exp;

                     Array < double, 2 > imp;
                     qi() {

                    };
                } qi;

                class qe {
                  public:

                    Array < double, 1 > exp;

                     Array < double, 1 > imp;
                     qe() {

                    };
                } qe;

                class qz {
                  public:

                    Array < double, 2 > exp;

                     Array < double, 2 > imp;
                     qz() {

                    };
                };
                Array < class qz, 1 > qz;

                class ui {
                  public:

                    Array < double, 2 > exp;

                     Array < double, 2 > imp;
                     ui() {

                    };
                } ui;

                class ujxb {
                  public:

                    Array < double, 1 > exp;

                     Array < double, 1 > imp;
                     ujxb() {

                    };
                } ujxb;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                values() {

                };
            };
            Array < class values, 1 > values;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            coresource & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class composition {
              public:

                Array < double, 1 > amn;

                 Array < double, 1 > zn;

                 Array < double, 1 > zion;

                 Array < int, 1 > imp_flag;

                 Array < std::string, 1 > label;
                 composition() {

                };
            } composition;

            class desc_impur {
              public:

                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;

                 Array < std::string, 1 > label;
                 desc_impur() {

                };
            } desc_impur;

            class compositions {
              public:

                class nuclei {
                  public:

                    double zn;

                    double amn;

                     std::string label;
                     nuclei() {
                        zn = EMPTY_DOUBLE;
                        amn = EMPTY_DOUBLE;

                    };
                };
                Array < class nuclei, 1 > nuclei;

                class ions {
                  public:

                    int nucindex;

                    double zion;

                    int imp_flag;

                     std::string label;
                     ions() {
                        nucindex = EMPTY_INT;
                        zion = EMPTY_DOUBLE;
                        imp_flag = EMPTY_INT;

                    };
                };
                Array < class ions, 1 > ions;

                class impurities {
                  public:

                    int nucindex;

                    int i_ion;

                    int nzimp;

                     Array < double, 1 > zmin;

                     Array < double, 1 > zmax;

                     Array < std::string, 1 > label;
                     impurities() {
                        nucindex = EMPTY_INT;
                        i_ion = EMPTY_INT;
                        nzimp = EMPTY_INT;

                    };
                };
                Array < class impurities, 1 > impurities;

                class neutralscomp {
                  public:

                    class neutcomp {
                      public:

                        int nucindex;

                        int multiplicity;
                         neutcomp() {
                            nucindex = EMPTY_INT;
                            multiplicity = EMPTY_INT;

                        };
                    };
                    Array < class neutcomp, 1 > neutcomp;

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    };
                    Array < class type, 1 > type;

                    std::string label;
                    neutralscomp() {

                    };
                };
                Array < class neutralscomp, 1 > neutralscomp;

                class edgespecies {
                  public:

                    int nucindex;

                    double zmin;

                    double zmax;

                     std::string label;
                     edgespecies() {
                        nucindex = EMPTY_INT;
                        zmin = EMPTY_DOUBLE;
                        zmax = EMPTY_DOUBLE;

                    };
                };
                Array < class edgespecies, 1 > edgespecies;

                class signature {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     signature() {
                        flag = EMPTY_INT;

                    };
                } signature;
                compositions() {

                };
            } compositions;

            class values {
              public:

                class transportid {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     transportid() {
                        flag = EMPTY_INT;

                    };
                } transportid;

                Array < double, 1 > rho_tor_norm;

                Array < double, 1 > rho_tor;

                Array < double, 1 > sigma;

                class ni_transp {
                  public:

                    Array < double, 3 > diff_eff;

                     Array < double, 3 > vconv_eff;

                     Array < double, 2 > flux;

                    class off_diagonal {
                      public:

                        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() {

                        };
                    } off_diagonal;

                    int flag;
                    ni_transp() {
                        flag = EMPTY_INT;

                    };
                } ni_transp;

                class ne_transp {
                  public:

                    Array < double, 2 > diff_eff;

                     Array < double, 2 > vconv_eff;

                     Array < double, 1 > flux;

                    class off_diagonal {
                      public:

                        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() {

                        };
                    } off_diagonal;

                    int flag;
                    ne_transp() {
                        flag = EMPTY_INT;

                    };
                } ne_transp;

                class nz_transp {
                  public:

                    Array < double, 2 > diff_eff;

                     Array < double, 2 > vconv_eff;

                     Array < double, 2 > exchange;

                     Array < double, 2 > flux;

                    int flag;
                     nz_transp() {
                        flag = EMPTY_INT;

                    };
                };
                Array < class nz_transp, 1 > nz_transp;

                class ti_transp {
                  public:

                    Array < double, 2 > diff_eff;

                     Array < double, 2 > vconv_eff;

                     Array < double, 2 > exchange;

                     Array < double, 2 > qgi;

                     Array < double, 2 > flux;

                    class off_diagonal {
                      public:

                        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() {

                        };
                    } off_diagonal;

                    int flag;
                    ti_transp() {
                        flag = EMPTY_INT;

                    };
                } ti_transp;

                class te_transp {
                  public:

                    Array < double, 1 > diff_eff;

                     Array < double, 1 > vconv_eff;

                     Array < double, 1 > flux;

                    class off_diagonal {
                      public:

                        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() {

                        };
                    } off_diagonal;

                    int flag;
                    te_transp() {
                        flag = EMPTY_INT;

                    };
                } te_transp;

                class tz_transp {
                  public:

                    Array < double, 2 > diff_eff;

                     Array < double, 2 > vconv_eff;

                     Array < double, 2 > exchange;

                     Array < double, 2 > flux;

                    int flag;
                     tz_transp() {
                        flag = EMPTY_INT;

                    };
                };
                Array < class tz_transp, 1 > tz_transp;

                class vtor_transp {
                  public:

                    Array < double, 2 > diff_eff;

                     Array < double, 2 > vconv_eff;

                     Array < double, 2 > flux;

                    class off_diagonal {
                      public:

                        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() {

                        };
                    } off_diagonal;

                    int flag;
                    vtor_transp() {
                        flag = EMPTY_INT;

                    };
                } vtor_transp;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                values() {

                };
            };
            Array < class values, 1 > values;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            coretransp & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class setup {
              public:

                class position {
                  public:

                    class r {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         r() {

                        };
                    } r;

                    class z {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         z() {

                        };
                    } z;

                    class phi {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         phi() {

                        };
                    } phi;
                    position() {

                    };
                } position;
                setup() {

                };
            } setup;

            class measure {
              public:

                class ti {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     ti() {

                    };
                } ti;

                class vtor {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     vtor() {

                    };
                } vtor;

                class vpol {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     vpol() {

                    };
                } vpol;
                measure() {

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            cxdiag & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class composition {
              public:

                Array < double, 1 > amn;

                 Array < double, 1 > zn;

                 Array < double, 1 > zion;

                 Array < int, 1 > imp_flag;

                 Array < std::string, 1 > label;
                 composition() {

                };
            } composition;

            class compositions {
              public:

                class nuclei {
                  public:

                    double zn;

                    double amn;

                     std::string label;
                     nuclei() {
                        zn = EMPTY_DOUBLE;
                        amn = EMPTY_DOUBLE;

                    };
                };
                Array < class nuclei, 1 > nuclei;

                class ions {
                  public:

                    int nucindex;

                    double zion;

                    int imp_flag;

                     std::string label;
                     ions() {
                        nucindex = EMPTY_INT;
                        zion = EMPTY_DOUBLE;
                        imp_flag = EMPTY_INT;

                    };
                };
                Array < class ions, 1 > ions;

                class impurities {
                  public:

                    int nucindex;

                    int i_ion;

                    int nzimp;

                     Array < double, 1 > zmin;

                     Array < double, 1 > zmax;

                     Array < std::string, 1 > label;
                     impurities() {
                        nucindex = EMPTY_INT;
                        i_ion = EMPTY_INT;
                        nzimp = EMPTY_INT;

                    };
                };
                Array < class impurities, 1 > impurities;

                class neutralscomp {
                  public:

                    class neutcomp {
                      public:

                        int nucindex;

                        int multiplicity;
                         neutcomp() {
                            nucindex = EMPTY_INT;
                            multiplicity = EMPTY_INT;

                        };
                    };
                    Array < class neutcomp, 1 > neutcomp;

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    };
                    Array < class type, 1 > type;

                    std::string label;
                    neutralscomp() {

                    };
                };
                Array < class neutralscomp, 1 > neutralscomp;

                class edgespecies {
                  public:

                    int nucindex;

                    double zmin;

                    double zmax;

                     std::string label;
                     edgespecies() {
                        nucindex = EMPTY_INT;
                        zmin = EMPTY_DOUBLE;
                        zmax = EMPTY_DOUBLE;

                    };
                };
                Array < class edgespecies, 1 > edgespecies;

                class signature {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     signature() {
                        flag = EMPTY_INT;

                    };
                } signature;
                compositions() {

                };
            } compositions;

            class distri_vec {
              public:

                class wave_id {
                  public:

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    } type;

                    std::string name;

                    int index;
                    wave_id() {
                        index = EMPTY_INT;

                    };
                };
                Array < class wave_id, 1 > wave_id;

                class source_id {
                  public:

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    } type;

                    std::string name;

                    int index;
                    source_id() {
                        index = EMPTY_INT;

                    };
                };
                Array < class source_id, 1 > source_id;

                int calc_spec;

                int gyro_type;

                class global_param {
                  public:

                    double n_particles;

                    double enrg;

                    double enrg_para;

                     Array < double, 1 > pow_coll_i;

                    double pow_coll_e;

                    class therm_src {
                      public:

                        double particles;

                        double power;

                        double torque;
                         therm_src() {
                            particles = EMPTY_DOUBLE;
                            power = EMPTY_DOUBLE;
                            torque = EMPTY_DOUBLE;

                        };
                    } therm_src;

                    class losses {
                      public:

                        class orb_loss {
                          public:

                            double particles;

                            double power;

                            double torque;
                             orb_loss() {
                                particles = EMPTY_DOUBLE;
                                power = EMPTY_DOUBLE;
                                torque = EMPTY_DOUBLE;

                            };
                        } orb_loss;

                        class neutr_loss {
                          public:

                            double particles;

                            double power;

                            double torque;
                             neutr_loss() {
                                particles = EMPTY_DOUBLE;
                                power = EMPTY_DOUBLE;
                                torque = EMPTY_DOUBLE;

                            };
                        } neutr_loss;
                        losses() {

                        };
                    } losses;

                    double cur_dr_tor;

                    Array < double, 1 > trq_i;

                    double trq_e;

                    double trq_j_rxb;

                    class nucl_reac_th {
                      public:

                        Array < double, 1 > rate;

                         Array < double, 1 > power;
                         nucl_reac_th() {

                        };
                    } nucl_reac_th;

                    class nucl_reac_sf {
                      public:

                        double rate;

                        double power;
                         nucl_reac_sf() {
                            rate = EMPTY_DOUBLE;
                            power = EMPTY_DOUBLE;

                        };
                    } nucl_reac_sf;
                    global_param() {
                        n_particles = EMPTY_DOUBLE;
                        enrg = EMPTY_DOUBLE;
                        enrg_para = EMPTY_DOUBLE;
                        pow_coll_e = EMPTY_DOUBLE;
                        cur_dr_tor = EMPTY_DOUBLE;
                        trq_e = EMPTY_DOUBLE;
                        trq_j_rxb = EMPTY_DOUBLE;

                    };
                } global_param;

                class profiles_1d {
                  public:

                    Array < double, 1 > rho_tor_norm;

                     Array < double, 1 > rho_tor;

                     Array < double, 1 > psi;

                     Array < double, 1 > dens;

                     Array < double, 1 > enrgd_tot;

                     Array < double, 1 > enrgd_para;

                     Array < double, 2 > powd_coll_i;

                     Array < double, 1 > powd_coll_e;

                    class therm_srcd {
                      public:

                        Array < double, 1 > particlesd;

                         Array < double, 1 > powerd;

                         Array < double, 1 > torqued;
                         therm_srcd() {

                        };
                    } therm_srcd;

                    class lossesd {
                      public:

                        class orb_loss {
                          public:

                            Array < double, 1 > particlesd;

                             Array < double, 1 > powerd;

                             Array < double, 1 > torqued;
                             orb_loss() {

                            };
                        } orb_loss;

                        class neutr_loss {
                          public:

                            Array < double, 1 > particlesd;

                             Array < double, 1 > powerd;

                             Array < double, 1 > torqued;
                             neutr_loss() {

                            };
                        } neutr_loss;
                        lossesd() {

                        };
                    } lossesd;

                    Array < double, 1 > curd_fp;

                    Array < double, 1 > curd_dr;

                    Array < double, 2 > trqd_i;

                    Array < double, 1 > trqd_e;

                    Array < double, 1 > trqd_jrxb;

                    class nucl_rd_th {
                      public:

                        Array < double, 2 > rated;

                         Array < double, 2 > powerd;
                         nucl_rd_th() {

                        };
                    } nucl_rd_th;

                    class nucl_rd_sf {
                      public:

                        Array < double, 1 > rate;

                         Array < double, 1 > power;
                         nucl_rd_sf() {

                        };
                    } nucl_rd_sf;

                    Array < double, 1 > enrg_tot;

                    Array < double, 1 > enrg_para;

                    Array < double, 2 > pow_coll_i;

                    Array < double, 1 > pow_coll_e;

                    class therm_src {
                      public:

                        Array < double, 1 > particles;

                         Array < double, 1 > power;

                         Array < double, 1 > torque;
                         therm_src() {

                        };
                    } therm_src;

                    class losses {
                      public:

                        class orb_loss {
                          public:

                            Array < double, 1 > particles;

                             Array < double, 1 > power;

                             Array < double, 1 > torque;
                             orb_loss() {

                            };
                        } orb_loss;

                        class neutr_loss {
                          public:

                            Array < double, 1 > particles;

                             Array < double, 1 > power;

                             Array < double, 1 > torque;
                             neutr_loss() {

                            };
                        } neutr_loss;
                        losses() {

                        };
                    } losses;

                    Array < double, 1 > cur_fp;

                    Array < double, 1 > cur_dr;

                    Array < double, 2 > trq_i;

                    Array < double, 1 > trq_e;

                    Array < double, 1 > trq_j_rxb;

                    class nucl_reac_th {
                      public:

                        Array < double, 2 > rate;

                         Array < double, 2 > power;
                         nucl_reac_th() {

                        };
                    } nucl_reac_th;

                    class nucl_reac_sf {
                      public:

                        Array < double, 1 > rate;

                         Array < double, 1 > power;
                         nucl_reac_sf() {

                        };
                    } nucl_reac_sf;
                    profiles_1d() {

                    };
                } profiles_1d;

                class dist_func {
                  public:

                    int is_delta_f;

                    class markers {
                      public:

                        class variable_ids {
                          public:

                            std::string id;

                            int flag;

                             std::string description;
                             variable_ids() {
                                flag = EMPTY_INT;

                            };
                        };
                        Array < class variable_ids, 1 > variable_ids;

                        Array < double, 2 > coord;

                        Array < double, 1 > weight;
                        markers() {

                        };
                    } markers;

                    class f_expan_topo {
                      public:

                        class grid_info {
                          public:

                            int grid_type;

                            int ngriddim;

                             Array < int, 1 > grid_coord;

                            int thin_orbits;

                             std::string topology;

                            class omnigen_surf {
                              public:

                                class rz {
                                  public:

                                    Array < double, 1 > r;

                                     Array < double, 1 > z;
                                     rz() {

                                    };
                                } rz;

                                Array < double, 1 > s;
                                omnigen_surf() {

                                };
                            };
                            Array < class omnigen_surf, 1 > omnigen_surf;
                            grid_info() {
                                grid_type = EMPTY_INT;
                                ngriddim = EMPTY_INT;
                                thin_orbits = EMPTY_INT;

                            };
                        } grid_info;

                        class topo_regions {
                          public:

                            int ind_omnigen;

                             Array < double, 6 > dim1;

                             Array < double, 6 > dim2;

                             Array < double, 6 > dim3;

                             Array < double, 6 > dim4;

                             Array < double, 6 > dim5;

                             Array < double, 6 > dim6;

                             Array < double, 6 > jacobian;

                             Array < double, 6 > distfunc;
                             topo_regions() {
                                ind_omnigen = EMPTY_INT;

                            };
                        };
                        Array < class topo_regions, 1 > topo_regions;
                        f_expan_topo() {

                        };
                    };
                    Array < class f_expan_topo, 1 > f_expan_topo;

                    class f_expansion {
                      public:

                        class grid {
                          public:

                            int uid;

                             std::string id;

                            class spaces {
                              public:

                                Array < int, 1 > geotype;

                                 Array < std::string, 1 > geotypeid;

                                 Array < int, 2 > coordtype;

                                class objects {
                                  public:

                                    Array < int, 2 > boundary;

                                     Array < int, 3 > neighbour;

                                     Array < double, 4 > geo;

                                     Array < double, 2 > measure;
                                     objects() {

                                    };
                                };
                                 Array < class objects, 1 > objects;

                                 Array < int, 1 > xpoints;
                                 spaces() {

                                };
                            };
                            Array < class spaces, 1 > spaces;

                            class subgrids {
                              public:

                                std::string id;

                                class list {
                                  public:

                                    Array < int, 1 > cls;

                                    class indset {
                                      public:

                                        Array < int, 1 > range;

                                         Array < int, 1 > ind;
                                         indset() {

                                        };
                                    };
                                     Array < class indset, 1 > indset;

                                     Array < int, 2 > ind;
                                     list() {

                                    };
                                };
                                Array < class list, 1 > list;
                                subgrids() {

                                };
                            };
                            Array < class subgrids, 1 > subgrids;

                            class metric {
                              public:

                                class measure {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     measure() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class measure, 1 > measure;

                                class g11 {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     g11() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class g11, 1 > g11;

                                class g12 {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     g12() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class g12, 1 > g12;

                                class g13 {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     g13() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class g13, 1 > g13;

                                class g22 {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     g22() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class g22, 1 > g22;

                                class g23 {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     g23() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class g23, 1 > g23;

                                class g33 {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     g33() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class g33, 1 > g33;

                                class jacobian {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     jacobian() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class jacobian, 1 > jacobian;
                                metric() {

                                };
                            } metric;

                            class geo {
                              public:

                                int geotype;

                                 std::string geotypeid;

                                 Array < int, 1 > coordtype;

                                class geo_matrix {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     geo_matrix() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class geo_matrix, 1 > geo_matrix;

                                class measure {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     measure() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class measure, 1 > measure;
                                geo() {
                                    geotype = EMPTY_INT;

                                };
                            };
                            Array < class geo, 1 > geo;

                            class bases {
                              public:

                                int griduid;

                                 std::string label;

                                class comp {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     comp() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class comp, 1 > comp;

                                Array < int, 1 > align;

                                Array < std::string, 1 > alignid;

                                int basis;
                                bases() {
                                    griduid = EMPTY_INT;
                                    basis = EMPTY_INT;

                                };
                            };
                            Array < class bases, 1 > bases;
                            grid() {
                                uid = EMPTY_INT;

                            };
                        } grid;

                        class values {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             values() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        } values;
                        f_expansion() {

                        };
                    };
                    Array < class f_expansion, 1 > f_expansion;
                    dist_func() {
                        is_delta_f = EMPTY_INT;

                    };
                } dist_func;

                class input_src {
                  public:

                    class particle_src {
                      public:

                        class total {
                          public:

                            double particles;

                            double power;

                            double torque;
                             total() {
                                particles = EMPTY_DOUBLE;
                                power = EMPTY_DOUBLE;
                                torque = EMPTY_DOUBLE;

                            };
                        } total;

                        class volume_intgr {
                          public:

                            Array < double, 1 > particles;

                             Array < double, 1 > power;

                             Array < double, 1 > torque;
                             volume_intgr() {

                            };
                        } volume_intgr;

                        class flux_surf_av {
                          public:

                            Array < double, 1 > particlesd;

                             Array < double, 1 > powerd;

                             Array < double, 1 > torqued;
                             flux_surf_av() {

                            };
                        } flux_surf_av;
                        particle_src() {

                        };
                    } particle_src;

                    class wave_src {
                      public:

                        std::string type;

                        double wave_power;

                         Array < double, 1 > wave_powerd;
                         wave_src() {
                            wave_power = EMPTY_DOUBLE;

                        };
                    } wave_src;
                    input_src() {

                    };
                } input_src;

                class nucl_reac {
                  public:

                    Array < int, 1 > point_reac;

                     Array < int, 1 > id_reac;
                     nucl_reac() {

                    };
                } nucl_reac;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                distri_vec() {
                    calc_spec = EMPTY_INT;
                    gyro_type = EMPTY_INT;

                };
            };
            Array < class distri_vec, 1 > distri_vec;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            distribution & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class composition {
              public:

                Array < double, 1 > amn;

                 Array < double, 1 > zn;

                 Array < double, 1 > zion;

                 Array < int, 1 > imp_flag;

                 Array < std::string, 1 > label;
                 composition() {

                };
            } composition;

            class compositions {
              public:

                class nuclei {
                  public:

                    double zn;

                    double amn;

                     std::string label;
                     nuclei() {
                        zn = EMPTY_DOUBLE;
                        amn = EMPTY_DOUBLE;

                    };
                };
                Array < class nuclei, 1 > nuclei;

                class ions {
                  public:

                    int nucindex;

                    double zion;

                    int imp_flag;

                     std::string label;
                     ions() {
                        nucindex = EMPTY_INT;
                        zion = EMPTY_DOUBLE;
                        imp_flag = EMPTY_INT;

                    };
                };
                Array < class ions, 1 > ions;

                class impurities {
                  public:

                    int nucindex;

                    int i_ion;

                    int nzimp;

                     Array < double, 1 > zmin;

                     Array < double, 1 > zmax;

                     Array < std::string, 1 > label;
                     impurities() {
                        nucindex = EMPTY_INT;
                        i_ion = EMPTY_INT;
                        nzimp = EMPTY_INT;

                    };
                };
                Array < class impurities, 1 > impurities;

                class neutralscomp {
                  public:

                    class neutcomp {
                      public:

                        int nucindex;

                        int multiplicity;
                         neutcomp() {
                            nucindex = EMPTY_INT;
                            multiplicity = EMPTY_INT;

                        };
                    };
                    Array < class neutcomp, 1 > neutcomp;

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    };
                    Array < class type, 1 > type;

                    std::string label;
                    neutralscomp() {

                    };
                };
                Array < class neutralscomp, 1 > neutralscomp;

                class edgespecies {
                  public:

                    int nucindex;

                    double zmin;

                    double zmax;

                     std::string label;
                     edgespecies() {
                        nucindex = EMPTY_INT;
                        zmin = EMPTY_DOUBLE;
                        zmax = EMPTY_DOUBLE;

                    };
                };
                Array < class edgespecies, 1 > edgespecies;

                class signature {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     signature() {
                        flag = EMPTY_INT;

                    };
                } signature;
                compositions() {

                };
            } compositions;

            class source {
              public:

                class source_id {
                  public:

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    } type;

                    std::string name;

                    int index;
                    source_id() {
                        index = EMPTY_INT;

                    };
                };
                Array < class source_id, 1 > source_id;

                int src_spec;

                int gyro_type;

                class global_param {
                  public:

                    class src_pow {
                      public:

                        double value;

                        double abserror;

                        double relerror;
                         src_pow() {
                            value = EMPTY_DOUBLE;
                            abserror = EMPTY_DOUBLE;
                            relerror = EMPTY_DOUBLE;

                        };
                    } src_pow;

                    class src_rate {
                      public:

                        double value;

                        double abserror;

                        double relerror;
                         src_rate() {
                            value = EMPTY_DOUBLE;
                            abserror = EMPTY_DOUBLE;
                            relerror = EMPTY_DOUBLE;

                        };
                    } src_rate;
                    global_param() {

                    };
                } global_param;

                class profiles_1d {
                  public:

                    Array < double, 1 > rho_tor_norm;

                     Array < double, 1 > rho_tor;

                     Array < double, 1 > psi;

                    class pow_den {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         pow_den() {

                        };
                    } pow_den;

                    class src_rate {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         src_rate() {

                        };
                    } src_rate;
                    profiles_1d() {

                    };
                } profiles_1d;

                class profiles_2d {
                  public:

                    Array < int, 1 > grid_coord;

                     Array < double, 2 > dim1;

                     Array < double, 2 > dim2;

                     Array < double, 2 > g11;

                     Array < double, 2 > g12;

                     Array < double, 2 > g21;

                     Array < double, 2 > g22;

                    class pow_den {
                      public:

                        Array < double, 2 > value;

                         Array < double, 2 > abserror;

                         Array < double, 2 > relerror;
                         pow_den() {

                        };
                    } pow_den;

                    class src_rate {
                      public:

                        Array < double, 2 > value;

                         Array < double, 2 > abserror;

                         Array < double, 2 > relerror;
                         src_rate() {

                        };
                    } src_rate;
                    profiles_2d() {

                    };
                } profiles_2d;

                class line_srcprof {
                  public:

                    Array < double, 1 > rho_tor;

                     Array < double, 1 > rho_tor_norm;

                     Array < double, 1 > psi;

                     Array < double, 1 > R;

                     Array < double, 1 > Z;

                     Array < double, 1 > theta;

                     Array < double, 1 > theta_id;

                     Array < double, 2 > th2th_pol;

                     Array < double, 1 > pitch;

                     Array < double, 1 > energy;

                     Array < double, 1 > ang_momentum;

                     Array < double, 1 > src_rate;
                     line_srcprof() {

                    };
                };
                Array < class line_srcprof, 1 > line_srcprof;

                class source_rate {
                  public:

                    class grid {
                      public:

                        int uid;

                         std::string id;

                        class spaces {
                          public:

                            Array < int, 1 > geotype;

                             Array < std::string, 1 > geotypeid;

                             Array < int, 2 > coordtype;

                            class objects {
                              public:

                                Array < int, 2 > boundary;

                                 Array < int, 3 > neighbour;

                                 Array < double, 4 > geo;

                                 Array < double, 2 > measure;
                                 objects() {

                                };
                            };
                             Array < class objects, 1 > objects;

                             Array < int, 1 > xpoints;
                             spaces() {

                            };
                        };
                        Array < class spaces, 1 > spaces;

                        class subgrids {
                          public:

                            std::string id;

                            class list {
                              public:

                                Array < int, 1 > cls;

                                class indset {
                                  public:

                                    Array < int, 1 > range;

                                     Array < int, 1 > ind;
                                     indset() {

                                    };
                                };
                                 Array < class indset, 1 > indset;

                                 Array < int, 2 > ind;
                                 list() {

                                };
                            };
                            Array < class list, 1 > list;
                            subgrids() {

                            };
                        };
                        Array < class subgrids, 1 > subgrids;

                        class metric {
                          public:

                            class measure {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 measure() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class measure, 1 > measure;

                            class g11 {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 g11() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class g11, 1 > g11;

                            class g12 {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 g12() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class g12, 1 > g12;

                            class g13 {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 g13() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class g13, 1 > g13;

                            class g22 {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 g22() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class g22, 1 > g22;

                            class g23 {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 g23() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class g23, 1 > g23;

                            class g33 {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 g33() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class g33, 1 > g33;

                            class jacobian {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 jacobian() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class jacobian, 1 > jacobian;
                            metric() {

                            };
                        } metric;

                        class geo {
                          public:

                            int geotype;

                             std::string geotypeid;

                             Array < int, 1 > coordtype;

                            class geo_matrix {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 geo_matrix() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class geo_matrix, 1 > geo_matrix;

                            class measure {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 measure() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class measure, 1 > measure;
                            geo() {
                                geotype = EMPTY_INT;

                            };
                        };
                        Array < class geo, 1 > geo;

                        class bases {
                          public:

                            int griduid;

                             std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;

                            int basis;
                            bases() {
                                griduid = EMPTY_INT;
                                basis = EMPTY_INT;

                            };
                        };
                        Array < class bases, 1 > bases;
                        grid() {
                            uid = EMPTY_INT;

                        };
                    } grid;

                    class value {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         value() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    } value;
                    source_rate() {

                    };
                } source_rate;

                class source_grid {
                  public:

                    class grid_info {
                      public:

                        int grid_type;

                        int ngriddim;

                         Array < int, 1 > grid_coord;

                         Array < int, 1 > discrete_dims;
                         grid_info() {
                            grid_type = EMPTY_INT;
                            ngriddim = EMPTY_INT;

                        };
                    } grid_info;

                    Array < double, 6 > dim1;

                    Array < double, 6 > dim2;

                    Array < double, 6 > dim3;

                    Array < double, 6 > dim4;

                    Array < double, 6 > dim5;

                    Array < double, 6 > dim6;

                    Array < double, 6 > jacobian;

                    Array < double, 6 > source;
                    source_grid() {

                    };
                } source_grid;

                class markers {
                  public:

                    class variable_ids {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         variable_ids() {
                            flag = EMPTY_INT;

                        };
                    };
                    Array < class variable_ids, 1 > variable_ids;

                    Array < double, 2 > coord;

                    Array < double, 1 > weight;
                    markers() {

                    };
                } markers;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                source() {
                    src_spec = EMPTY_INT;
                    gyro_type = EMPTY_INT;

                };
            };
            Array < class source, 1 > source;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            distsource & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class setup {
              public:

                Array < double, 1 > frequency;

                 Array < std::string, 1 > harmonic;

                class position {
                  public:

                    class r {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         r() {

                        };
                    } r;

                    class z {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         z() {

                        };
                    } z;

                    class phi {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         phi() {

                        };
                    } phi;
                    position() {

                    };
                } position;
                setup() {

                };
            } setup;

            class measure {
              public:

                class te {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     te() {

                    };
                } te;
                measure() {

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            ecediag & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class grid {
              public:

                int uid;

                 std::string id;

                class spaces {
                  public:

                    Array < int, 1 > geotype;

                     Array < std::string, 1 > geotypeid;

                     Array < int, 2 > coordtype;

                    class objects {
                      public:

                        Array < int, 2 > boundary;

                         Array < int, 3 > neighbour;

                         Array < double, 4 > geo;

                         Array < double, 2 > measure;
                         objects() {

                        };
                    };
                     Array < class objects, 1 > objects;

                     Array < int, 1 > xpoints;
                     spaces() {

                    };
                };
                Array < class spaces, 1 > spaces;

                class subgrids {
                  public:

                    std::string id;

                    class list {
                      public:

                        Array < int, 1 > cls;

                        class indset {
                          public:

                            Array < int, 1 > range;

                             Array < int, 1 > ind;
                             indset() {

                            };
                        };
                         Array < class indset, 1 > indset;

                         Array < int, 2 > ind;
                         list() {

                        };
                    };
                    Array < class list, 1 > list;
                    subgrids() {

                    };
                };
                Array < class subgrids, 1 > subgrids;

                class metric {
                  public:

                    class measure {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         measure() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class measure, 1 > measure;

                    class g11 {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         g11() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class g11, 1 > g11;

                    class g12 {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         g12() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class g12, 1 > g12;

                    class g13 {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         g13() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class g13, 1 > g13;

                    class g22 {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         g22() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class g22, 1 > g22;

                    class g23 {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         g23() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class g23, 1 > g23;

                    class g33 {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         g33() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class g33, 1 > g33;

                    class jacobian {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         jacobian() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class jacobian, 1 > jacobian;
                    metric() {

                    };
                } metric;

                class geo {
                  public:

                    int geotype;

                     std::string geotypeid;

                     Array < int, 1 > coordtype;

                    class geo_matrix {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         geo_matrix() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class geo_matrix, 1 > geo_matrix;

                    class measure {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         measure() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class measure, 1 > measure;
                    geo() {
                        geotype = EMPTY_INT;

                    };
                };
                Array < class geo, 1 > geo;

                class bases {
                  public:

                    int griduid;

                     std::string label;

                    class comp {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         comp() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class comp, 1 > comp;

                    Array < int, 1 > align;

                    Array < std::string, 1 > alignid;

                    int basis;
                    bases() {
                        griduid = EMPTY_INT;
                        basis = EMPTY_INT;

                    };
                };
                Array < class bases, 1 > bases;
                grid() {
                    uid = EMPTY_INT;

                };
            } grid;

            class species {
              public:

                std::string label;

                double amn;

                double zn;

                double zmin;

                double zmax;
                 species() {
                    amn = EMPTY_DOUBLE;
                    zn = EMPTY_DOUBLE;
                    zmin = EMPTY_DOUBLE;
                    zmax = EMPTY_DOUBLE;

                };
            };
            Array < class species, 1 > species;

            class compositions {
              public:

                class nuclei {
                  public:

                    double zn;

                    double amn;

                     std::string label;
                     nuclei() {
                        zn = EMPTY_DOUBLE;
                        amn = EMPTY_DOUBLE;

                    };
                };
                Array < class nuclei, 1 > nuclei;

                class ions {
                  public:

                    int nucindex;

                    double zion;

                    int imp_flag;

                     std::string label;
                     ions() {
                        nucindex = EMPTY_INT;
                        zion = EMPTY_DOUBLE;
                        imp_flag = EMPTY_INT;

                    };
                };
                Array < class ions, 1 > ions;

                class impurities {
                  public:

                    int nucindex;

                    int i_ion;

                    int nzimp;

                     Array < double, 1 > zmin;

                     Array < double, 1 > zmax;

                     Array < std::string, 1 > label;
                     impurities() {
                        nucindex = EMPTY_INT;
                        i_ion = EMPTY_INT;
                        nzimp = EMPTY_INT;

                    };
                };
                Array < class impurities, 1 > impurities;

                class neutralscomp {
                  public:

                    class neutcomp {
                      public:

                        int nucindex;

                        int multiplicity;
                         neutcomp() {
                            nucindex = EMPTY_INT;
                            multiplicity = EMPTY_INT;

                        };
                    };
                    Array < class neutcomp, 1 > neutcomp;

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    };
                    Array < class type, 1 > type;

                    std::string label;
                    neutralscomp() {

                    };
                };
                Array < class neutralscomp, 1 > neutralscomp;

                class edgespecies {
                  public:

                    int nucindex;

                    double zmin;

                    double zmax;

                     std::string label;
                     edgespecies() {
                        nucindex = EMPTY_INT;
                        zmin = EMPTY_DOUBLE;
                        zmax = EMPTY_DOUBLE;

                    };
                };
                Array < class edgespecies, 1 > edgespecies;

                class signature {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     signature() {
                        flag = EMPTY_INT;

                    };
                } signature;
                compositions() {

                };
            } compositions;

            class fluid {
              public:

                class ne {
                  public:

                    class value {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         value() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class value, 1 > value;

                    class bndvalue {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         bndvalue() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class bndvalue, 1 > bndvalue;

                    class flux {
                      public:

                        int griduid;

                         std::string label;

                        class comp {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             comp() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class comp, 1 > comp;

                        Array < int, 1 > align;

                        Array < std::string, 1 > alignid;

                        int basis;
                        flux() {
                            griduid = EMPTY_INT;
                            basis = EMPTY_INT;

                        };
                    };
                    Array < class flux, 1 > flux;

                    class bndflux {
                      public:

                        int griduid;

                         std::string label;

                        class comp {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             comp() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class comp, 1 > comp;

                        Array < int, 1 > align;

                        Array < std::string, 1 > alignid;

                        int basis;
                        bndflux() {
                            griduid = EMPTY_INT;
                            basis = EMPTY_INT;

                        };
                    };
                    Array < class bndflux, 1 > bndflux;

                    class transpcoeff {
                      public:

                        class d {
                          public:

                            std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;
                            d() {

                            };
                        } d;

                        class v {
                          public:

                            std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;
                            v() {

                            };
                        } v;
                        transpcoeff() {

                        };
                    };
                    Array < class transpcoeff, 1 > transpcoeff;

                    class source {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         source() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class source, 1 > source;
                    ne() {

                    };
                } ne;

                class ni {
                  public:

                    class value {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         value() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class value, 1 > value;

                    class bndvalue {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         bndvalue() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class bndvalue, 1 > bndvalue;

                    class flux {
                      public:

                        int griduid;

                         std::string label;

                        class comp {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             comp() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class comp, 1 > comp;

                        Array < int, 1 > align;

                        Array < std::string, 1 > alignid;

                        int basis;
                        flux() {
                            griduid = EMPTY_INT;
                            basis = EMPTY_INT;

                        };
                    };
                    Array < class flux, 1 > flux;

                    class bndflux {
                      public:

                        int griduid;

                         std::string label;

                        class comp {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             comp() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class comp, 1 > comp;

                        Array < int, 1 > align;

                        Array < std::string, 1 > alignid;

                        int basis;
                        bndflux() {
                            griduid = EMPTY_INT;
                            basis = EMPTY_INT;

                        };
                    };
                    Array < class bndflux, 1 > bndflux;

                    class transpcoeff {
                      public:

                        class d {
                          public:

                            std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;
                            d() {

                            };
                        } d;

                        class v {
                          public:

                            std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;
                            v() {

                            };
                        } v;
                        transpcoeff() {

                        };
                    };
                    Array < class transpcoeff, 1 > transpcoeff;

                    class source {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         source() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class source, 1 > source;
                    ni() {

                    };
                };
                Array < class ni, 1 > ni;

                class ve {
                  public:

                    int griduid;

                    int basis;

                    class comps {
                      public:

                        class value {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             value() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class value, 1 > value;

                        class bndvalue {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             bndvalue() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class bndvalue, 1 > bndvalue;

                        class flux {
                          public:

                            int griduid;

                             std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;

                            int basis;
                            flux() {
                                griduid = EMPTY_INT;
                                basis = EMPTY_INT;

                            };
                        };
                        Array < class flux, 1 > flux;

                        class bndflux {
                          public:

                            int griduid;

                             std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;

                            int basis;
                            bndflux() {
                                griduid = EMPTY_INT;
                                basis = EMPTY_INT;

                            };
                        };
                        Array < class bndflux, 1 > bndflux;

                        class transpcoeff {
                          public:

                            class d {
                              public:

                                std::string label;

                                class comp {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     comp() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class comp, 1 > comp;

                                Array < int, 1 > align;

                                Array < std::string, 1 > alignid;
                                d() {

                                };
                            } d;

                            class v {
                              public:

                                std::string label;

                                class comp {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     comp() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class comp, 1 > comp;

                                Array < int, 1 > align;

                                Array < std::string, 1 > alignid;
                                v() {

                                };
                            } v;
                            transpcoeff() {

                            };
                        };
                        Array < class transpcoeff, 1 > transpcoeff;

                        class source {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             source() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class source, 1 > source;
                        comps() {

                        };
                    };
                    Array < class comps, 1 > comps;

                    Array < int, 1 > align;

                    Array < std::string, 1 > alignid;
                    ve() {
                        griduid = EMPTY_INT;
                        basis = EMPTY_INT;

                    };
                } ve;

                class vi {
                  public:

                    int griduid;

                    int basis;

                     Array < int, 1 > align;

                     Array < std::string, 1 > alignid;

                    class comps {
                      public:

                        class value {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             value() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class value, 1 > value;

                        class bndvalue {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             bndvalue() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class bndvalue, 1 > bndvalue;

                        class flux {
                          public:

                            int griduid;

                             std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;

                            int basis;
                            flux() {
                                griduid = EMPTY_INT;
                                basis = EMPTY_INT;

                            };
                        };
                        Array < class flux, 1 > flux;

                        class bndflux {
                          public:

                            int griduid;

                             std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;

                            int basis;
                            bndflux() {
                                griduid = EMPTY_INT;
                                basis = EMPTY_INT;

                            };
                        };
                        Array < class bndflux, 1 > bndflux;

                        class transpcoeff {
                          public:

                            class d {
                              public:

                                std::string label;

                                class comp {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     comp() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class comp, 1 > comp;

                                Array < int, 1 > align;

                                Array < std::string, 1 > alignid;
                                d() {

                                };
                            } d;

                            class v {
                              public:

                                std::string label;

                                class comp {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     comp() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class comp, 1 > comp;

                                Array < int, 1 > align;

                                Array < std::string, 1 > alignid;
                                v() {

                                };
                            } v;
                            transpcoeff() {

                            };
                        };
                        Array < class transpcoeff, 1 > transpcoeff;

                        class source {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             source() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class source, 1 > source;
                        comps() {

                        };
                    };
                    Array < class comps, 1 > comps;
                    vi() {
                        griduid = EMPTY_INT;
                        basis = EMPTY_INT;

                    };
                };
                Array < class vi, 1 > vi;

                class te {
                  public:

                    class value {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         value() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class value, 1 > value;

                    class bndvalue {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         bndvalue() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class bndvalue, 1 > bndvalue;

                    class flux {
                      public:

                        int griduid;

                         std::string label;

                        class comp {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             comp() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class comp, 1 > comp;

                        Array < int, 1 > align;

                        Array < std::string, 1 > alignid;

                        int basis;
                        flux() {
                            griduid = EMPTY_INT;
                            basis = EMPTY_INT;

                        };
                    };
                    Array < class flux, 1 > flux;

                    class bndflux {
                      public:

                        int griduid;

                         std::string label;

                        class comp {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             comp() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class comp, 1 > comp;

                        Array < int, 1 > align;

                        Array < std::string, 1 > alignid;

                        int basis;
                        bndflux() {
                            griduid = EMPTY_INT;
                            basis = EMPTY_INT;

                        };
                    };
                    Array < class bndflux, 1 > bndflux;

                    class transpcoeff {
                      public:

                        class d {
                          public:

                            std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;
                            d() {

                            };
                        } d;

                        class v {
                          public:

                            std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;
                            v() {

                            };
                        } v;
                        transpcoeff() {

                        };
                    };
                    Array < class transpcoeff, 1 > transpcoeff;

                    class source {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         source() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class source, 1 > source;
                    te() {

                    };
                } te;

                class ti {
                  public:

                    class value {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         value() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class value, 1 > value;

                    class bndvalue {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         bndvalue() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class bndvalue, 1 > bndvalue;

                    class flux {
                      public:

                        int griduid;

                         std::string label;

                        class comp {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             comp() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class comp, 1 > comp;

                        Array < int, 1 > align;

                        Array < std::string, 1 > alignid;

                        int basis;
                        flux() {
                            griduid = EMPTY_INT;
                            basis = EMPTY_INT;

                        };
                    };
                    Array < class flux, 1 > flux;

                    class bndflux {
                      public:

                        int griduid;

                         std::string label;

                        class comp {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             comp() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class comp, 1 > comp;

                        Array < int, 1 > align;

                        Array < std::string, 1 > alignid;

                        int basis;
                        bndflux() {
                            griduid = EMPTY_INT;
                            basis = EMPTY_INT;

                        };
                    };
                    Array < class bndflux, 1 > bndflux;

                    class transpcoeff {
                      public:

                        class d {
                          public:

                            std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;
                            d() {

                            };
                        } d;

                        class v {
                          public:

                            std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;
                            v() {

                            };
                        } v;
                        transpcoeff() {

                        };
                    };
                    Array < class transpcoeff, 1 > transpcoeff;

                    class source {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         source() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class source, 1 > source;
                    ti() {

                    };
                };
                Array < class ti, 1 > ti;

                class te_aniso {
                  public:

                    int griduid;

                    int basis;

                    class comps {
                      public:

                        class value {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             value() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class value, 1 > value;

                        class bndvalue {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             bndvalue() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class bndvalue, 1 > bndvalue;

                        class flux {
                          public:

                            int griduid;

                             std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;

                            int basis;
                            flux() {
                                griduid = EMPTY_INT;
                                basis = EMPTY_INT;

                            };
                        };
                        Array < class flux, 1 > flux;

                        class bndflux {
                          public:

                            int griduid;

                             std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;

                            int basis;
                            bndflux() {
                                griduid = EMPTY_INT;
                                basis = EMPTY_INT;

                            };
                        };
                        Array < class bndflux, 1 > bndflux;

                        class transpcoeff {
                          public:

                            class d {
                              public:

                                std::string label;

                                class comp {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     comp() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class comp, 1 > comp;

                                Array < int, 1 > align;

                                Array < std::string, 1 > alignid;
                                d() {

                                };
                            } d;

                            class v {
                              public:

                                std::string label;

                                class comp {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     comp() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class comp, 1 > comp;

                                Array < int, 1 > align;

                                Array < std::string, 1 > alignid;
                                v() {

                                };
                            } v;
                            transpcoeff() {

                            };
                        };
                        Array < class transpcoeff, 1 > transpcoeff;

                        class source {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             source() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class source, 1 > source;
                        comps() {

                        };
                    };
                    Array < class comps, 1 > comps;

                    Array < int, 1 > align;

                    Array < std::string, 1 > alignid;
                    te_aniso() {
                        griduid = EMPTY_INT;
                        basis = EMPTY_INT;

                    };
                } te_aniso;

                class ti_aniso {
                  public:

                    int griduid;

                    int basis;

                     Array < int, 1 > align;

                     Array < std::string, 1 > alignid;

                    class comps {
                      public:

                        class value {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             value() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class value, 1 > value;

                        class bndvalue {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             bndvalue() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class bndvalue, 1 > bndvalue;

                        class flux {
                          public:

                            int griduid;

                             std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;

                            int basis;
                            flux() {
                                griduid = EMPTY_INT;
                                basis = EMPTY_INT;

                            };
                        };
                        Array < class flux, 1 > flux;

                        class bndflux {
                          public:

                            int griduid;

                             std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;

                            int basis;
                            bndflux() {
                                griduid = EMPTY_INT;
                                basis = EMPTY_INT;

                            };
                        };
                        Array < class bndflux, 1 > bndflux;

                        class transpcoeff {
                          public:

                            class d {
                              public:

                                std::string label;

                                class comp {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     comp() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class comp, 1 > comp;

                                Array < int, 1 > align;

                                Array < std::string, 1 > alignid;
                                d() {

                                };
                            } d;

                            class v {
                              public:

                                std::string label;

                                class comp {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     comp() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class comp, 1 > comp;

                                Array < int, 1 > align;

                                Array < std::string, 1 > alignid;
                                v() {

                                };
                            } v;
                            transpcoeff() {

                            };
                        };
                        Array < class transpcoeff, 1 > transpcoeff;

                        class source {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             source() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class source, 1 > source;
                        comps() {

                        };
                    };
                    Array < class comps, 1 > comps;
                    ti_aniso() {
                        griduid = EMPTY_INT;
                        basis = EMPTY_INT;

                    };
                };
                Array < class ti_aniso, 1 > ti_aniso;

                class po {
                  public:

                    class value {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         value() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class value, 1 > value;

                    class bndvalue {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         bndvalue() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class bndvalue, 1 > bndvalue;

                    class flux {
                      public:

                        int griduid;

                         std::string label;

                        class comp {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             comp() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class comp, 1 > comp;

                        Array < int, 1 > align;

                        Array < std::string, 1 > alignid;

                        int basis;
                        flux() {
                            griduid = EMPTY_INT;
                            basis = EMPTY_INT;

                        };
                    };
                    Array < class flux, 1 > flux;

                    class bndflux {
                      public:

                        int griduid;

                         std::string label;

                        class comp {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             comp() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class comp, 1 > comp;

                        Array < int, 1 > align;

                        Array < std::string, 1 > alignid;

                        int basis;
                        bndflux() {
                            griduid = EMPTY_INT;
                            basis = EMPTY_INT;

                        };
                    };
                    Array < class bndflux, 1 > bndflux;

                    class transpcoeff {
                      public:

                        class d {
                          public:

                            std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;
                            d() {

                            };
                        } d;

                        class v {
                          public:

                            std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;
                            v() {

                            };
                        } v;
                        transpcoeff() {

                        };
                    };
                    Array < class transpcoeff, 1 > transpcoeff;

                    class source {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         source() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class source, 1 > source;
                    po() {

                    };
                } po;

                class j {
                  public:

                    int griduid;

                    int basis;

                    class comps {
                      public:

                        class value {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             value() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class value, 1 > value;

                        class bndvalue {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             bndvalue() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class bndvalue, 1 > bndvalue;

                        class flux {
                          public:

                            int griduid;

                             std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;

                            int basis;
                            flux() {
                                griduid = EMPTY_INT;
                                basis = EMPTY_INT;

                            };
                        };
                        Array < class flux, 1 > flux;

                        class bndflux {
                          public:

                            int griduid;

                             std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;

                            int basis;
                            bndflux() {
                                griduid = EMPTY_INT;
                                basis = EMPTY_INT;

                            };
                        };
                        Array < class bndflux, 1 > bndflux;

                        class transpcoeff {
                          public:

                            class d {
                              public:

                                std::string label;

                                class comp {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     comp() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class comp, 1 > comp;

                                Array < int, 1 > align;

                                Array < std::string, 1 > alignid;
                                d() {

                                };
                            } d;

                            class v {
                              public:

                                std::string label;

                                class comp {
                                  public:

                                    int griduid;

                                    int subgrid;

                                     Array < double, 1 > scalar;

                                     Array < double, 2 > vector;

                                     Array < double, 3 > matrix;
                                     comp() {
                                        griduid = EMPTY_INT;
                                        subgrid = EMPTY_INT;

                                    };
                                };
                                Array < class comp, 1 > comp;

                                Array < int, 1 > align;

                                Array < std::string, 1 > alignid;
                                v() {

                                };
                            } v;
                            transpcoeff() {

                            };
                        };
                        Array < class transpcoeff, 1 > transpcoeff;

                        class source {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             source() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class source, 1 > source;
                        comps() {

                        };
                    };
                    Array < class comps, 1 > comps;

                    Array < int, 1 > align;

                    Array < std::string, 1 > alignid;
                    j() {
                        griduid = EMPTY_INT;
                        basis = EMPTY_INT;

                    };
                } j;

                class b {
                  public:

                    int griduid;

                     std::string label;

                    class comp {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         comp() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class comp, 1 > comp;

                    Array < int, 1 > align;

                    Array < std::string, 1 > alignid;

                    int basis;
                    b() {
                        griduid = EMPTY_INT;
                        basis = EMPTY_INT;

                    };
                };
                Array < class b, 1 > b;
                fluid() {

                };
            } fluid;

            class kinetic {
              public:

                class f {
                  public:

                    class value {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         value() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class value, 1 > value;

                    class bndvalue {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         bndvalue() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class bndvalue, 1 > bndvalue;

                    class fluxes {
                      public:

                        int griduid;

                         std::string label;

                        class comp {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             comp() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class comp, 1 > comp;

                        Array < int, 1 > align;

                        Array < std::string, 1 > alignid;

                        int basis;
                        fluxes() {
                            griduid = EMPTY_INT;
                            basis = EMPTY_INT;

                        };
                    };
                    Array < class fluxes, 1 > fluxes;

                    class source {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         source() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class source, 1 > source;
                    f() {

                    };
                };
                Array < class f, 1 > f;
                kinetic() {

                };
            } kinetic;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } codeparam;

            double time;
            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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            edge & operator()(int index) {
                return array(index);
            };
            edge & operator[](int index) {
                return array(index);
            };
            int extent(int dim = 0) {
                return array.extent(dim);
            };
        };

        class efcc:Cpo {
          private:
            int expIdx;
            bool connected;
          public:
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class coil {
              public:

                class desc_coils {
                  public:

                    std::string name;

                    double res;

                    int nturns;

                     std::string closed;

                    class edges {
                      public:

                        class edge_rzphi {
                          public:

                            Array < double, 1 > r;

                             Array < double, 1 > z;

                             Array < double, 1 > phi;
                             edge_rzphi() {

                            };
                        } edge_rzphi;
                        edges() {

                        };
                    };
                    Array < class edges, 1 > edges;
                    desc_coils() {
                        res = EMPTY_DOUBLE;
                        nturns = EMPTY_INT;

                    };
                } desc_coils;

                class coilcurrent {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     coilcurrent() {

                    };
                } coilcurrent;

                class coilvoltage {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     coilvoltage() {

                    };
                } coilvoltage;
                coil() {

                };
            };
            Array < class coil, 1 > coil;

            double time;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } codeparam;
            efcc();
            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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            friend ostream & operator <<(ostream & os, const efcc & obj);
        };
        class efccArray:Cpo {
          private:
            int expIdx;
            bool connected;


          public:
             efccArray() {
                connected = false;
            } void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            }
            Array < efcc, 1 > array;

            int get();
            int put();
            int deleteAll();
            int deleteAll(int idx);
            int get(int idx);
            int put(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            efcc & operator()(int index) {
                return array(index);
            };
            efcc & 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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class eqconstraint {
              public:

                class bpol {
                  public:

                    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() {
                        time = EMPTY_DOUBLE;

                    };
                } bpol;

                class bvac_r {
                  public:

                    double measured;

                     std::string source;

                    double time;

                    int exact;

                    double weight;

                    double sigma;

                    double calculated;

                    double chi2;
                     bvac_r() {
                        measured = EMPTY_DOUBLE;
                        time = EMPTY_DOUBLE;
                        exact = EMPTY_INT;
                        weight = EMPTY_DOUBLE;
                        sigma = EMPTY_DOUBLE;
                        calculated = EMPTY_DOUBLE;
                        chi2 = EMPTY_DOUBLE;

                    };
                } bvac_r;

                class diamagflux {
                  public:

                    double measured;

                     std::string source;

                    double time;

                    int exact;

                    double weight;

                    double sigma;

                    double calculated;

                    double chi2;
                     diamagflux() {
                        measured = EMPTY_DOUBLE;
                        time = EMPTY_DOUBLE;
                        exact = EMPTY_INT;
                        weight = EMPTY_DOUBLE;
                        sigma = EMPTY_DOUBLE;
                        calculated = EMPTY_DOUBLE;
                        chi2 = EMPTY_DOUBLE;

                    };
                } diamagflux;

                class faraday {
                  public:

                    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() {
                        time = EMPTY_DOUBLE;

                    };
                } faraday;

                class flux {
                  public:

                    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() {
                        time = EMPTY_DOUBLE;

                    };
                } flux;

                class i_plasma {
                  public:

                    double measured;

                     std::string source;

                    double time;

                    int exact;

                    double weight;

                    double sigma;

                    double calculated;

                    double chi2;
                     i_plasma() {
                        measured = EMPTY_DOUBLE;
                        time = EMPTY_DOUBLE;
                        exact = EMPTY_INT;
                        weight = EMPTY_DOUBLE;
                        sigma = EMPTY_DOUBLE;
                        calculated = EMPTY_DOUBLE;
                        chi2 = EMPTY_DOUBLE;

                    };
                } i_plasma;

                class isoflux {
                  public:

                    class position {
                      public:

                        Array < double, 1 > r;

                         Array < double, 1 > z;
                         position() {

                        };
                    } position;

                    std::string source;

                    Array < double, 1 > weight;

                    Array < double, 1 > sigma;

                    Array < double, 1 > calculated;

                    Array < double, 1 > chi2;
                    isoflux() {

                    };
                } isoflux;

                class jsurf {
                  public:

                    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() {
                        time = EMPTY_DOUBLE;

                    };
                } jsurf;

                class magnet_iron {
                  public:

                    class mr {
                      public:

                        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() {
                            time = EMPTY_DOUBLE;

                        };
                    } mr;

                    class mz {
                      public:

                        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() {
                            time = EMPTY_DOUBLE;

                        };
                    } mz;
                    magnet_iron() {

                    };
                } magnet_iron;

                class mse {
                  public:

                    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() {
                        time = EMPTY_DOUBLE;

                    };
                } mse;

                class ne {
                  public:

                    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() {
                        time = EMPTY_DOUBLE;

                    };
                } ne;

                class pfcurrent {
                  public:

                    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() {
                        time = EMPTY_DOUBLE;

                    };
                } pfcurrent;

                class pressure {
                  public:

                    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() {
                        time = EMPTY_DOUBLE;

                    };
                } pressure;

                class q {
                  public:

                    Array < double, 1 > qvalue;

                    class position {
                      public:

                        Array < double, 1 > r;

                         Array < double, 1 > z;
                         position() {

                        };
                    } position;

                    std::string source;

                    int exact;

                    Array < double, 1 > weight;

                    Array < double, 1 > sigma;

                    Array < double, 1 > calculated;

                    Array < double, 1 > chi2;
                    q() {
                        exact = EMPTY_INT;

                    };
                } q;

                class xpts {
                  public:

                    class position {
                      public:

                        Array < double, 1 > r;

                         Array < double, 1 > z;
                         position() {

                        };
                    } position;

                    std::string source;

                    Array < double, 1 > weight;

                    Array < double, 1 > sigma;

                    Array < double, 1 > calculated;

                    Array < double, 1 > chi2;
                    xpts() {

                    };
                } xpts;
                eqconstraint() {

                };
            } eqconstraint;

            class eqgeometry {
              public:

                std::string source;

                int boundarytype;

                class boundary {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;
                     boundary() {

                    };
                };
                Array < class boundary, 1 > boundary;

                class geom_axis {
                  public:

                    double r;

                    double z;
                     geom_axis() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;

                    };
                } geom_axis;

                double a_minor;

                double elongation;

                double elong_upper;

                double elong_lower;

                double tria_upper;

                double tria_lower;

                class xpts {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;
                     xpts() {

                    };
                };
                Array < class xpts, 1 > xpts;

                class left_low_st {
                  public:

                    double r;

                    double z;
                     left_low_st() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;

                    };
                } left_low_st;

                class right_low_st {
                  public:

                    double r;

                    double z;
                     right_low_st() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;

                    };
                } right_low_st;

                class left_up_st {
                  public:

                    double r;

                    double z;
                     left_up_st() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;

                    };
                } left_up_st;

                class right_up_st {
                  public:

                    double r;

                    double z;
                     right_up_st() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;

                    };
                } right_up_st;

                class active_limit {
                  public:

                    double r;

                    double z;
                     active_limit() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;

                    };
                } active_limit;

                double ang_lcms_upo;

                double ang_lcms_upi;

                double ang_lcms_lwo;

                double ang_lcms_lwi;
                eqgeometry() {
                    boundarytype = EMPTY_INT;
                    a_minor = EMPTY_DOUBLE;
                    elongation = EMPTY_DOUBLE;
                    elong_upper = EMPTY_DOUBLE;
                    elong_lower = EMPTY_DOUBLE;
                    tria_upper = EMPTY_DOUBLE;
                    tria_lower = EMPTY_DOUBLE;
                    ang_lcms_upo = EMPTY_DOUBLE;
                    ang_lcms_upi = EMPTY_DOUBLE;
                    ang_lcms_lwo = EMPTY_DOUBLE;
                    ang_lcms_lwi = EMPTY_DOUBLE;

                };
            } eqgeometry;

            class flush {
              public:

                class datainfo {
                  public:

                    std::string dataprovider;

                    std::string putdate;

                    std::string source;

                    std::string comment;

                    int cocos;

                    int id;

                    int isref;

                    class whatref {
                      public:

                        std::string user;

                        std::string machine;

                        int shot;

                        int run;

                        int occurrence;
                         whatref() {
                            shot = EMPTY_INT;
                            run = EMPTY_INT;
                            occurrence = EMPTY_INT;

                        };
                    } whatref;

                    class putinfo {
                      public:

                        std::string putmethod;

                        std::string putaccess;

                        std::string putlocation;

                        std::string rights;
                        putinfo() {

                        };
                    } putinfo;
                    datainfo() {
                        cocos = EMPTY_INT;
                        id = EMPTY_INT;
                        isref = EMPTY_INT;

                    };
                } datainfo;

                class position {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;
                     position() {

                    };
                } position;

                Array < double, 2 > coef;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                flush() {

                };
            } flush;

            class global_param {
              public:

                double beta_pol;

                double beta_tor;

                double beta_normal;

                double i_plasma;

                double li;

                double volume;

                double area;

                double psi_ax;

                double psi_bound;

                class mag_axis {
                  public:

                    class position {
                      public:

                        double r;

                        double z;
                         position() {
                            r = EMPTY_DOUBLE;
                            z = EMPTY_DOUBLE;

                        };
                    } position;

                    double bphi;

                    double q;
                    mag_axis() {
                        bphi = EMPTY_DOUBLE;
                        q = EMPTY_DOUBLE;

                    };
                } mag_axis;

                double q_95;

                double q_min;

                class toroid_field {
                  public:

                    double r0;

                    double b0;
                     toroid_field() {
                        r0 = EMPTY_DOUBLE;
                        b0 = EMPTY_DOUBLE;

                    };
                } toroid_field;

                double w_mhd;

                double gamma;
                global_param() {
                    beta_pol = EMPTY_DOUBLE;
                    beta_tor = EMPTY_DOUBLE;
                    beta_normal = EMPTY_DOUBLE;
                    i_plasma = EMPTY_DOUBLE;
                    li = EMPTY_DOUBLE;
                    volume = EMPTY_DOUBLE;
                    area = EMPTY_DOUBLE;
                    psi_ax = EMPTY_DOUBLE;
                    psi_bound = EMPTY_DOUBLE;
                    q_95 = EMPTY_DOUBLE;
                    q_min = EMPTY_DOUBLE;
                    w_mhd = EMPTY_DOUBLE;
                    gamma = EMPTY_DOUBLE;

                };
            } global_param;

            class profiles_1d {
              public:

                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 > dpsidrho_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 > dvdrho;

                 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;

                 Array < double, 1 > b_av;

                 Array < double, 1 > b_min;

                 Array < double, 1 > b_max;

                 Array < double, 1 > omega;

                 Array < double, 1 > omegaprime;

                 Array < double, 1 > mach_a;

                 Array < double, 1 > phi_flow;

                 Array < double, 1 > s_flow;

                 Array < double, 1 > h_flow;
                 profiles_1d() {

                };
            } profiles_1d;

            class profiles_2d {
              public:

                Array < std::string, 1 > grid_type;

                class grid {
                  public:

                    Array < double, 1 > dim1;

                     Array < double, 1 > dim2;

                     Array < int, 2 > connect;
                     grid() {

                    };
                } grid;

                Array < double, 2 > r;

                Array < double, 2 > z;

                Array < double, 2 > psi;

                Array < double, 2 > theta;

                Array < double, 2 > phi;

                Array < double, 2 > jphi;

                Array < double, 2 > jpar;

                Array < double, 2 > br;

                Array < double, 2 > bz;

                Array < double, 2 > bphi;

                Array < double, 2 > vphi;

                Array < double, 2 > vtheta;

                Array < double, 2 > rho_mass;

                Array < double, 2 > pressure;

                Array < double, 2 > temperature;
                profiles_2d() {

                };
            };
            Array < class profiles_2d, 1 > profiles_2d;

            class coord_sys {
              public:

                std::string grid_type;

                class grid {
                  public:

                    Array < double, 1 > dim1;

                     Array < double, 1 > dim2;
                     grid() {

                    };
                } 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;

                class position {
                  public:

                    Array < double, 2 > r;

                     Array < double, 2 > z;
                     position() {

                    };
                } position;
                coord_sys() {

                };
            } coord_sys;

            double time;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            equilibrium & operator()(int index) {
                return array(index);
            };
            equilibrium & operator[](int index) {
                return array(index);
            };
            int extent(int dim = 0) {
                return array.extent(dim);
            };
        };

        class fusiondiag:Cpo {
          private:
            int expIdx;
            bool connected;
          public:
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class fus_product {
              public:

                std::string product;

                std::string reaction;

                class collimator {
                  public:

                    class colli_circ {
                      public:

                        std::string name;

                        class setup_line {
                          public:

                            class pivot_point {
                              public:

                                Array < double, 1 > r;

                                 Array < double, 1 > z;

                                 Array < double, 1 > phi;
                                 pivot_point() {

                                };
                            } pivot_point;

                             Array < double, 1 > horchordang1;

                             Array < double, 1 > verchordang1;

                             Array < double, 1 > width;

                            class second_point {
                              public:

                                Array < double, 1 > r;

                                 Array < double, 1 > z;

                                 Array < double, 1 > phi;
                                 second_point() {

                                };
                            } second_point;

                            Array < double, 1 > horchordang2;

                            Array < double, 1 > verchordang2;

                            class third_point {
                              public:

                                Array < double, 1 > r;

                                 Array < double, 1 > z;

                                 Array < double, 1 > phi;
                                 third_point() {

                                };
                            } third_point;

                            int nchordpoints;
                            setup_line() {
                                nchordpoints = EMPTY_INT;

                            };
                        } setup_line;

                        class colliunit {
                          public:

                            Array < double, 1 > radius;

                            class centre {
                              public:

                                Array < double, 1 > r;

                                 Array < double, 1 > z;

                                 Array < double, 1 > phi;
                                 centre() {

                                };
                            } centre;
                            colliunit() {

                            };
                        };
                        Array < class colliunit, 1 > colliunit;
                        colli_circ() {

                        };
                    };
                    Array < class colli_circ, 1 > colli_circ;

                    class colli_poly {
                      public:

                        std::string name;

                        class setup_line {
                          public:

                            class pivot_point {
                              public:

                                Array < double, 1 > r;

                                 Array < double, 1 > z;

                                 Array < double, 1 > phi;
                                 pivot_point() {

                                };
                            } pivot_point;

                            Array < double, 1 > horchordang1;

                            Array < double, 1 > verchordang1;

                            Array < double, 1 > width;

                            class second_point {
                              public:

                                Array < double, 1 > r;

                                 Array < double, 1 > z;

                                 Array < double, 1 > phi;
                                 second_point() {

                                };
                            } second_point;

                            Array < double, 1 > horchordang2;

                            Array < double, 1 > verchordang2;

                            class third_point {
                              public:

                                Array < double, 1 > r;

                                 Array < double, 1 > z;

                                 Array < double, 1 > phi;
                                 third_point() {

                                };
                            } third_point;

                            int nchordpoints;
                            setup_line() {
                                nchordpoints = EMPTY_INT;

                            };
                        } setup_line;

                        class colliunit {
                          public:

                            double dimension;

                            class nodes {
                              public:

                                Array < double, 2 > r;

                                 Array < double, 2 > z;

                                 Array < double, 2 > phi;
                                 nodes() {

                                };
                            } nodes;
                            colliunit() {
                                dimension = EMPTY_DOUBLE;

                            };
                        };
                        Array < class colliunit, 1 > colliunit;
                        colli_poly() {

                        };
                    };
                    Array < class colli_poly, 1 > colli_poly;

                    class colli_3d {
                      public:

                        std::string name;

                        class voxels {
                          public:

                            class centre {
                              public:

                                double r;

                                double z;

                                double phi;
                                 centre() {
                                    r = EMPTY_DOUBLE;
                                    z = EMPTY_DOUBLE;
                                    phi = EMPTY_DOUBLE;

                                };
                            } centre;

                            class direction {
                              public:

                                double r;

                                double z;

                                double phi;
                                 direction() {
                                    r = EMPTY_DOUBLE;
                                    z = EMPTY_DOUBLE;
                                    phi = EMPTY_DOUBLE;

                                };
                            } direction;

                            double volume;

                            double solid_angle;
                            voxels() {
                                volume = EMPTY_DOUBLE;
                                solid_angle = EMPTY_DOUBLE;

                            };
                        };
                        Array < class voxels, 1 > voxels;
                        colli_3d() {

                        };
                    };
                    Array < class colli_3d, 1 > colli_3d;
                    collimator() {

                    };
                } collimator;

                class counts {
                  public:

                    std::string units;

                    class ct_chords {
                      public:

                        Array < std::string, 1 > name;

                        class energy {
                          public:

                            double value;

                            double abserror;

                            double relerror;
                             energy() {
                                value = EMPTY_DOUBLE;
                                abserror = EMPTY_DOUBLE;
                                relerror = EMPTY_DOUBLE;

                            };
                        } energy;

                        class measure {
                          public:

                            Array < double, 1 > value;

                             Array < double, 1 > abserror;

                             Array < double, 1 > relerror;
                             measure() {

                            };
                        } measure;
                        ct_chords() {

                        };
                    };
                    Array < class ct_chords, 1 > ct_chords;

                    class ct_energy {
                      public:

                        class energy {
                          public:

                            Array < double, 1 > value;

                             Array < double, 1 > abserror;

                             Array < double, 1 > relerror;
                             energy() {

                            };
                        } energy;

                        class measure {
                          public:

                            Array < double, 1 > value;

                             Array < double, 1 > abserror;

                             Array < double, 1 > relerror;
                             measure() {

                            };
                        } measure;
                        ct_energy() {

                        };
                    };
                    Array < class ct_energy, 1 > ct_energy;

                    class detect_ct {
                      public:

                        class energy {
                          public:

                            Array < double, 1 > value;

                             Array < double, 1 > abserror;

                             Array < double, 1 > relerror;
                             energy() {

                            };
                        } energy;

                        class measure {
                          public:

                            Array < double, 1 > value;

                             Array < double, 1 > abserror;

                             Array < double, 1 > relerror;
                             measure() {

                            };
                        } measure;

                        class diag_func {
                          public:

                            std::string description;

                            Array < double, 2 > transf_mat;
                             diag_func() {

                            };
                        } diag_func;
                        detect_ct() {

                        };
                    };
                    Array < class detect_ct, 1 > detect_ct;
                    counts() {

                    };
                } counts;

                class emissivity1d {
                  public:

                    std::string units;

                    class r {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         r() {

                        };
                    } r;

                    class z {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         z() {

                        };
                    } z;

                    class spec1d {
                      public:

                        class energy {
                          public:

                            double value;

                            double abserror;

                            double relerror;
                             energy() {
                                value = EMPTY_DOUBLE;
                                abserror = EMPTY_DOUBLE;
                                relerror = EMPTY_DOUBLE;

                            };
                        } energy;

                        class measure {
                          public:

                            Array < double, 1 > value;

                             Array < double, 1 > abserror;

                             Array < double, 1 > relerror;
                             measure() {

                            };
                        } measure;
                        spec1d() {

                        };
                    };
                    Array < class spec1d, 1 > spec1d;
                    emissivity1d() {

                    };
                } emissivity1d;

                class emissivity2d {
                  public:

                    std::string units;

                    class r {
                      public:

                        Array < double, 2 > value;

                         Array < double, 2 > abserror;

                         Array < double, 2 > relerror;
                         r() {

                        };
                    } r;

                    class z {
                      public:

                        Array < double, 2 > value;

                         Array < double, 2 > abserror;

                         Array < double, 2 > relerror;
                         z() {

                        };
                    } z;

                    class spec2d {
                      public:

                        class energy {
                          public:

                            double value;

                            double abserror;

                            double relerror;
                             energy() {
                                value = EMPTY_DOUBLE;
                                abserror = EMPTY_DOUBLE;
                                relerror = EMPTY_DOUBLE;

                            };
                        } energy;

                        class measure {
                          public:

                            Array < double, 2 > value;

                             Array < double, 2 > abserror;

                             Array < double, 2 > relerror;
                             measure() {

                            };
                        } measure;
                        spec2d() {

                        };
                    };
                    Array < class spec2d, 1 > spec2d;
                    emissivity2d() {

                    };
                } emissivity2d;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                fus_product() {

                };
            };
            Array < class fus_product, 1 > fus_product;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } codeparam;

            double time;
            fusiondiag();
            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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            friend ostream & operator <<(ostream & os, const fusiondiag & obj);
        };
        class fusiondiagArray:Cpo {
          private:
            int expIdx;
            bool connected;


          public:
             fusiondiagArray() {
                connected = false;
            } void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            }
            Array < fusiondiag, 1 > array;

            int get();
            int put();
            int deleteAll();
            int deleteAll(int idx);
            int get(int idx);
            int put(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            fusiondiag & operator()(int index) {
                return array(index);
            };
            fusiondiag & operator[](int index) {
                return array(index);
            };
            int extent(int dim = 0) {
                return array.extent(dim);
            };
        };

        class halphadiag:Cpo {
          private:
            int expIdx;
            bool connected;
          public:
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class setup {
              public:

                Array < std::string, 1 > name;

                class pivot_point {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;

                     Array < double, 1 > phi;
                     pivot_point() {

                    };
                } pivot_point;

                Array < double, 1 > horchordang;

                Array < double, 1 > verchordang;

                class second_point {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;

                     Array < double, 1 > phi;
                     second_point() {

                    };
                } second_point;

                class solidangle {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     solidangle() {

                    };
                } solidangle;
                setup() {

                };
            } setup;

            class intensity {
              public:

                Array < double, 1 > value;

                 Array < double, 1 > abserror;

                 Array < double, 1 > relerror;
                 intensity() {

                };
            } intensity;

            double time;
            halphadiag();
            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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            friend ostream & operator <<(ostream & os, const halphadiag & obj);
        };
        class halphadiagArray:Cpo {
          private:
            int expIdx;
            bool connected;


          public:
             halphadiagArray() {
                connected = false;
            } void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            }
            Array < halphadiag, 1 > array;

            int get();
            int put();
            int deleteAll();
            int deleteAll(int idx);
            int get(int idx);
            int put(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            halphadiag & operator()(int index) {
                return array(index);
            };
            halphadiag & 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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            std::string expression;

            class setup_line {
              public:

                class pivot_point {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;

                     Array < double, 1 > phi;
                     pivot_point() {

                    };
                } pivot_point;

                Array < double, 1 > horchordang1;

                Array < double, 1 > verchordang1;

                Array < double, 1 > width;

                class second_point {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;

                     Array < double, 1 > phi;
                     second_point() {

                    };
                } second_point;

                Array < double, 1 > horchordang2;

                Array < double, 1 > verchordang2;

                class third_point {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;

                     Array < double, 1 > phi;
                     third_point() {

                    };
                } third_point;

                int nchordpoints;
                setup_line() {
                    nchordpoints = EMPTY_INT;

                };
            } setup_line;

            class measure {
              public:

                Array < double, 1 > value;

                 Array < double, 1 > abserror;

                 Array < double, 1 > relerror;
                 measure() {

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            interfdiag & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class desc_iron {
              public:

                Array < std::string, 1 > name;

                Array < std::string, 1 > id;

                class permeability {
                  public:

                    Array < double, 2 > b;

                     Array < double, 2 > mur;
                     permeability() {

                    };
                } permeability;

                class geom_iron {
                  public:

                    Array < int, 1 > npoints;

                    class rzcoordinate {
                      public:

                        Array < double, 2 > r;

                         Array < double, 2 > z;
                         rzcoordinate() {

                        };
                    } rzcoordinate;
                    geom_iron() {

                    };
                } geom_iron;
                desc_iron() {

                };
            } desc_iron;

            class magnetise {
              public:

                class mr {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     mr() {

                    };
                } mr;

                class mz {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     mz() {

                    };
                } mz;
                magnetise() {

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            ironmodel & operator()(int index) {
                return array(index);
            };
            ironmodel & operator[](int index) {
                return array(index);
            };
            int extent(int dim = 0) {
                return array.extent(dim);
            };
        };

        class langmuirdiag:Cpo {
          private:
            int expIdx;
            bool connected;
          public:
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class potential {
              public:

                Array < std::string, 1 > name;

                Array < std::string, 1 > direction;

                class area {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     area() {

                    };
                } area;

                class position {
                  public:

                    class r {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         r() {

                        };
                    } r;

                    class z {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         z() {

                        };
                    } z;

                    class phi {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         phi() {

                        };
                    } phi;
                    position() {

                    };
                } position;

                class measure {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     measure() {

                    };
                } measure;
                potential() {

                };
            } potential;

            class bias {
              public:

                Array < std::string, 1 > name;

                Array < std::string, 1 > direction;

                class area {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     area() {

                    };
                } area;

                class position {
                  public:

                    class r {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         r() {

                        };
                    } r;

                    class z {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         z() {

                        };
                    } z;

                    class phi {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         phi() {

                        };
                    } phi;
                    position() {

                    };
                } position;

                class measure {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     measure() {

                    };
                } measure;
                bias() {

                };
            } bias;

            class jsat {
              public:

                Array < std::string, 1 > name;

                Array < std::string, 1 > direction;

                class area {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     area() {

                    };
                } area;

                class position {
                  public:

                    class r {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         r() {

                        };
                    } r;

                    class z {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         z() {

                        };
                    } z;

                    class phi {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         phi() {

                        };
                    } phi;
                    position() {

                    };
                } position;

                class measure {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     measure() {

                    };
                } measure;
                jsat() {

                };
            } jsat;

            class ne {
              public:

                Array < std::string, 1 > source;

                class position {
                  public:

                    class r {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         r() {

                        };
                    } r;

                    class z {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         z() {

                        };
                    } z;

                    class phi {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         phi() {

                        };
                    } phi;
                    position() {

                    };
                } position;

                class measure {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     measure() {

                    };
                } measure;
                ne() {

                };
            } ne;

            class te {
              public:

                Array < std::string, 1 > source;

                class position {
                  public:

                    class r {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         r() {

                        };
                    } r;

                    class z {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         z() {

                        };
                    } z;

                    class phi {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         phi() {

                        };
                    } phi;
                    position() {

                    };
                } position;

                class measure {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     measure() {

                    };
                } measure;
                te() {

                };
            } te;

            class machpar {
              public:

                Array < std::string, 1 > source;

                class position {
                  public:

                    class r {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         r() {

                        };
                    } r;

                    class z {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         z() {

                        };
                    } z;

                    class phi {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         phi() {

                        };
                    } phi;
                    position() {

                    };
                } position;

                class measure {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     measure() {

                    };
                } measure;
                machpar() {

                };
            } machpar;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } codeparam;

            double time;
            langmuirdiag();
            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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            friend ostream & operator <<(ostream & os, const langmuirdiag & obj);
        };
        class langmuirdiagArray:Cpo {
          private:
            int expIdx;
            bool connected;


          public:
             langmuirdiagArray() {
                connected = false;
            } void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            }
            Array < langmuirdiag, 1 > array;

            int get();
            int put();
            int deleteAll();
            int deleteAll(int idx);
            int get(int idx);
            int put(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            langmuirdiag & operator()(int index) {
                return array(index);
            };
            langmuirdiag & 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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            Array < std::string, 1 > name;

            Array < std::string, 1 > type;

            Array < double, 1 > frequency;

            Array < int, 1 > mode;

            class position {
              public:

                Array < double, 1 > r;

                 Array < double, 1 > z;

                 Array < double, 1 > phi;
                 position() {

                };
            } position;

            class spectrum {
              public:

                class phi_theta {
                  public:

                    Array < int, 1 > nn_phi;

                     Array < int, 1 > nn_theta;

                     Array < double, 2 > n_phi;

                     Array < double, 2 > n_theta;

                     Array < double, 3 > power;
                     phi_theta() {

                    };
                } phi_theta;

                class parallel {
                  public:

                    Array < int, 1 > nn_par;

                     Array < double, 2 > n_par;

                     Array < double, 1 > power;
                     parallel() {

                    };
                } parallel;
                spectrum() {

                };
            } spectrum;

            class beam {
              public:

                class spot {
                  public:

                    Array < double, 2 > waist;

                     Array < double, 1 > angle;
                     spot() {

                    };
                } spot;

                class phaseellipse {
                  public:

                    Array < double, 2 > invcurvrad;

                     Array < double, 1 > angle;
                     phaseellipse() {

                    };
                } phaseellipse;
                beam() {

                };
            } beam;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            launchs & operator()(int index) {
                return array(index);
            };
            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:

             class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class limiter_unit {
              public:

                std::string name;

                std::string closed;

                class position {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;
                     position() {

                    };
                } position;

                double eta;

                double delta;

                double permeability;
                limiter_unit() {
                    eta = EMPTY_DOUBLE;
                    delta = EMPTY_DOUBLE;
                    permeability = EMPTY_DOUBLE;

                };
            };
            Array < class limiter_unit, 1 > limiter_unit;
            limiter();
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            }
            int get();
            int get(int idx);
            int put();
            int put(int idx);
            void flush();
            void flush(int idx);
            void discard();
            void discard(int idx);
            friend ostream & operator <<(ostream & os, const limiter & obj);

        };

        class lithiumdiag:Cpo {
          private:
            int expIdx;
            bool connected;
          public:
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class setup {
              public:

                class position {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;

                     Array < double, 1 > phi;
                     position() {

                    };
                } position;
                setup() {

                };
            } setup;

            class measure {
              public:

                class ne {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     ne() {

                    };
                } ne;
                measure() {

                };
            } measure;

            double time;
            lithiumdiag();
            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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            friend ostream & operator <<(ostream & os, const lithiumdiag & obj);
        };
        class lithiumdiagArray:Cpo {
          private:
            int expIdx;
            bool connected;


          public:
             lithiumdiagArray() {
                connected = false;
            } void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            }
            Array < lithiumdiag, 1 > array;

            int get();
            int put();
            int deleteAll();
            int deleteAll(int idx);
            int get(int idx);
            int put(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            lithiumdiag & operator()(int index) {
                return array(index);
            };
            lithiumdiag & operator[](int index) {
                return array(index);
            };
            int extent(int dim = 0) {
                return array.extent(dim);
            };
        };

        class mhd:Cpo {
          private:
            int expIdx;
            bool connected;
          public:
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            Array < int, 1 > n;

            Array < double, 1 > frequency;

            Array < double, 1 > growthrate;

            class plasma {
              public:

                Array < double, 1 > psi;

                 Array < double, 3 > m;

                class disp_perp {
                  public:

                    Array < double, 3 > re;

                     Array < double, 3 > im;
                     disp_perp() {

                    };
                } disp_perp;

                class disp_par {
                  public:

                    Array < double, 3 > re;

                     Array < double, 3 > im;
                     disp_par() {

                    };
                } disp_par;

                Array < double, 1 > tau_alfven;

                Array < double, 1 > tau_resistive;

                class coord_sys {
                  public:

                    std::string grid_type;

                    class grid {
                      public:

                        Array < double, 1 > dim1;

                         Array < double, 1 > dim2;
                         grid() {

                        };
                    } 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;

                    class position {
                      public:

                        Array < double, 2 > r;

                         Array < double, 2 > z;
                         position() {

                        };
                    } position;
                    coord_sys() {

                    };
                } coord_sys;

                class a_pert {
                  public:

                    class coord1 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord1() {

                        };
                    } coord1;

                    class coord2 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord2() {

                        };
                    } coord2;

                    class coord3 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord3() {

                        };
                    } coord3;
                    a_pert() {

                    };
                } a_pert;

                class b_pert {
                  public:

                    class coord1 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord1() {

                        };
                    } coord1;

                    class coord2 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord2() {

                        };
                    } coord2;

                    class coord3 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord3() {

                        };
                    } coord3;
                    b_pert() {

                    };
                } b_pert;

                class v_pert {
                  public:

                    class coord1 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord1() {

                        };
                    } coord1;

                    class coord2 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord2() {

                        };
                    } coord2;

                    class coord3 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord3() {

                        };
                    } coord3;
                    v_pert() {

                    };
                } v_pert;

                class p_pert {
                  public:

                    Array < double, 3 > re;

                     Array < double, 3 > im;
                     p_pert() {

                    };
                } p_pert;

                class rho_mass_pert {
                  public:

                    Array < double, 3 > re;

                     Array < double, 3 > im;
                     rho_mass_pert() {

                    };
                } rho_mass_pert;

                class temp_pert {
                  public:

                    Array < double, 3 > re;

                     Array < double, 3 > im;
                     temp_pert() {

                    };
                } temp_pert;
                plasma() {

                };
            } plasma;

            class vacuum {
              public:

                Array < double, 3 > m;

                class coord_sys {
                  public:

                    std::string grid_type;

                    class grid {
                      public:

                        Array < double, 1 > dim1;

                         Array < double, 1 > dim2;
                         grid() {

                        };
                    } 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;

                    class position {
                      public:

                        Array < double, 2 > r;

                         Array < double, 2 > z;
                         position() {

                        };
                    } position;
                    coord_sys() {

                    };
                } coord_sys;

                class a_pert {
                  public:

                    class coord1 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord1() {

                        };
                    } coord1;

                    class coord2 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord2() {

                        };
                    } coord2;

                    class coord3 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord3() {

                        };
                    } coord3;
                    a_pert() {

                    };
                } a_pert;

                class b_pert {
                  public:

                    class coord1 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord1() {

                        };
                    } coord1;

                    class coord2 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord2() {

                        };
                    } coord2;

                    class coord3 {
                      public:

                        Array < double, 3 > re;

                         Array < double, 3 > im;
                         coord3() {

                        };
                    } coord3;
                    b_pert() {

                    };
                } b_pert;
                vacuum() {

                };
            } vacuum;

            double time;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            mhd & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class ip {
              public:

                double value;

                double abserror;

                double relerror;
                 ip() {
                    value = EMPTY_DOUBLE;
                    abserror = EMPTY_DOUBLE;
                    relerror = EMPTY_DOUBLE;

                };
            } ip;

            class diamagflux {
              public:

                double value;

                double abserror;

                double relerror;
                 diamagflux() {
                    value = EMPTY_DOUBLE;
                    abserror = EMPTY_DOUBLE;
                    relerror = EMPTY_DOUBLE;

                };
            } diamagflux;

            class flux_loops {
              public:

                class setup_floops {
                  public:

                    Array < std::string, 1 > name;

                    Array < std::string, 1 > id;

                    class position {
                      public:

                        Array < double, 2 > r;

                         Array < double, 2 > z;

                         Array < double, 2 > phi;
                         position() {

                        };
                    } position;

                    Array < int, 1 > npoints;
                    setup_floops() {

                    };
                } setup_floops;

                class measure {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     measure() {

                    };
                } measure;
                flux_loops() {

                };
            } flux_loops;

            class bpol_probes {
              public:

                class setup_bprobe {
                  public:

                    Array < std::string, 1 > name;

                    Array < std::string, 1 > id;

                    class position {
                      public:

                        Array < double, 1 > r;

                         Array < double, 1 > z;
                         position() {

                        };
                    } position;

                    Array < double, 1 > polangle;

                    Array < double, 1 > torangle;

                    Array < double, 1 > area;

                    Array < double, 1 > length;

                    Array < int, 1 > turns;
                    setup_bprobe() {

                    };
                } setup_bprobe;

                class measure {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     measure() {

                    };
                } measure;
                bpol_probes() {

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            magdiag & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class polarimetry {
              public:

                class setup {
                  public:

                    class rzgamma {
                      public:

                        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() {

                        };
                    } rzgamma;

                    Array < double, 2 > geom_coef;
                    setup() {

                    };
                } setup;

                class measure {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     measure() {

                    };
                } measure;
                polarimetry() {

                };
            } polarimetry;

            class spectral {
              public:

                class emissivity {
                  public:

                    Array < double, 1 > wavelength;

                    class emiss_chord {
                      public:

                        double volume;

                        class setup {
                          public:

                            Array < double, 1 > r;

                             Array < double, 1 > z;

                             Array < double, 1 > phi;
                             setup() {

                            };
                        } setup;

                        class polarization {
                          public:

                            class type {
                              public:

                                std::string id;

                                int flag;

                                 std::string description;
                                 type() {
                                    flag = EMPTY_INT;

                                };
                            } type;

                            Array < double, 2 > spec_emiss;
                            polarization() {

                            };
                        };
                        Array < class polarization, 1 > polarization;

                        Array < double, 1 > quantiaxis;
                        emiss_chord() {
                            volume = EMPTY_DOUBLE;

                        };
                    };
                    Array < class emiss_chord, 1 > emiss_chord;
                    emissivity() {

                    };
                } emissivity;

                class radiance {
                  public:

                    class wavelength {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         wavelength() {

                        };
                    } wavelength;

                    class radia_chord {
                      public:

                        class setup {
                          public:

                            class pivot_point {
                              public:

                                double r;

                                double z;

                                double phi;
                                 pivot_point() {
                                    r = EMPTY_DOUBLE;
                                    z = EMPTY_DOUBLE;
                                    phi = EMPTY_DOUBLE;

                                };
                            } pivot_point;

                            double horchordang;

                            double verchordang;

                            class second_point {
                              public:

                                double r;

                                double z;

                                double phi;
                                 second_point() {
                                    r = EMPTY_DOUBLE;
                                    z = EMPTY_DOUBLE;
                                    phi = EMPTY_DOUBLE;

                                };
                            } second_point;
                            setup() {
                                horchordang = EMPTY_DOUBLE;
                                verchordang = EMPTY_DOUBLE;

                            };
                        } setup;

                        class stokes {
                          public:

                            class type {
                              public:

                                std::string id;

                                int flag;

                                 std::string description;
                                 type() {
                                    flag = EMPTY_INT;

                                };
                            } type;

                            Array < double, 2 > vector;
                            stokes() {

                            };
                        };
                        Array < class stokes, 1 > stokes;

                        class totradiance {
                          public:

                            Array < double, 1 > value;

                             Array < double, 1 > abserror;

                             Array < double, 1 > relerror;
                             totradiance() {

                            };
                        } totradiance;
                        radia_chord() {

                        };
                    };
                    Array < class radia_chord, 1 > radia_chord;
                    radiance() {

                    };
                } radiance;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                spectral() {

                };
            } spectral;

            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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            msediag & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class nbi_unit {
              public:

                std::string name;

                class inj_spec {
                  public:

                    double amn;

                    double zn;
                     inj_spec() {
                        amn = EMPTY_DOUBLE;
                        zn = EMPTY_DOUBLE;

                    };
                } inj_spec;

                class pow_unit {
                  public:

                    double value;

                    double abserror;

                    double relerror;
                     pow_unit() {
                        value = EMPTY_DOUBLE;
                        abserror = EMPTY_DOUBLE;
                        relerror = EMPTY_DOUBLE;

                    };
                } pow_unit;

                class inj_eng_unit {
                  public:

                    double value;

                    double abserror;

                    double relerror;
                     inj_eng_unit() {
                        value = EMPTY_DOUBLE;
                        abserror = EMPTY_DOUBLE;
                        relerror = EMPTY_DOUBLE;

                    };
                } inj_eng_unit;

                class beamcurrfrac {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     beamcurrfrac() {

                    };
                } beamcurrfrac;

                class beampowrfrac {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     beampowrfrac() {

                    };
                } beampowrfrac;

                class setup_inject {
                  public:

                    class position {
                      public:

                        double r;

                        double z;

                        double phi;
                         position() {
                            r = EMPTY_DOUBLE;
                            z = EMPTY_DOUBLE;
                            phi = EMPTY_DOUBLE;

                        };
                    } position;

                    double tang_rad;

                    double angle;

                    int direction;

                    double focal_len_hz;

                    double focal_len_vc;

                    class divergence {
                      public:

                        Array < double, 1 > frac_divcomp;

                         Array < double, 1 > div_vert;

                         Array < double, 1 > div_horiz;
                         divergence() {

                        };
                    } divergence;

                    class beamlets {
                      public:

                        class position {
                          public:

                            Array < double, 1 > r;

                             Array < double, 1 > z;

                             Array < double, 1 > phi;
                             position() {

                            };
                        } position;

                        Array < double, 1 > tang_rad_blt;

                        Array < double, 1 > angle_blt;

                        Array < double, 1 > pow_frc_blt;
                        beamlets() {

                        };
                    } beamlets;
                    setup_inject() {
                        tang_rad = EMPTY_DOUBLE;
                        angle = EMPTY_DOUBLE;
                        direction = EMPTY_INT;
                        focal_len_hz = EMPTY_DOUBLE;
                        focal_len_vc = EMPTY_DOUBLE;

                    };
                } setup_inject;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                nbi_unit() {

                };
            };
            Array < class nbi_unit, 1 > nbi_unit;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            nbi & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            Array < double, 1 > rho_tor_norm;

            Array < double, 1 > rho_tor;

            class composition {
              public:

                Array < double, 1 > amn;

                 Array < double, 1 > zn;

                 Array < double, 1 > zion;

                 Array < int, 1 > imp_flag;

                 Array < std::string, 1 > label;
                 composition() {

                };
            } composition;

            class desc_impur {
              public:

                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;

                 Array < std::string, 1 > label;
                 desc_impur() {

                };
            } desc_impur;

            class compositions {
              public:

                class nuclei {
                  public:

                    double zn;

                    double amn;

                     std::string label;
                     nuclei() {
                        zn = EMPTY_DOUBLE;
                        amn = EMPTY_DOUBLE;

                    };
                };
                Array < class nuclei, 1 > nuclei;

                class ions {
                  public:

                    int nucindex;

                    double zion;

                    int imp_flag;

                     std::string label;
                     ions() {
                        nucindex = EMPTY_INT;
                        zion = EMPTY_DOUBLE;
                        imp_flag = EMPTY_INT;

                    };
                };
                Array < class ions, 1 > ions;

                class impurities {
                  public:

                    int nucindex;

                    int i_ion;

                    int nzimp;

                     Array < double, 1 > zmin;

                     Array < double, 1 > zmax;

                     Array < std::string, 1 > label;
                     impurities() {
                        nucindex = EMPTY_INT;
                        i_ion = EMPTY_INT;
                        nzimp = EMPTY_INT;

                    };
                };
                Array < class impurities, 1 > impurities;

                class neutralscomp {
                  public:

                    class neutcomp {
                      public:

                        int nucindex;

                        int multiplicity;
                         neutcomp() {
                            nucindex = EMPTY_INT;
                            multiplicity = EMPTY_INT;

                        };
                    };
                    Array < class neutcomp, 1 > neutcomp;

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    };
                    Array < class type, 1 > type;

                    std::string label;
                    neutralscomp() {

                    };
                };
                Array < class neutralscomp, 1 > neutralscomp;

                class edgespecies {
                  public:

                    int nucindex;

                    double zmin;

                    double zmax;

                     std::string label;
                     edgespecies() {
                        nucindex = EMPTY_INT;
                        zmin = EMPTY_DOUBLE;
                        zmax = EMPTY_DOUBLE;

                    };
                };
                Array < class edgespecies, 1 > edgespecies;

                class signature {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     signature() {
                        flag = EMPTY_INT;

                    };
                } signature;
                compositions() {

                };
            } compositions;

            class ni_neo {
              public:

                Array < double, 2 > diff_eff;

                 Array < double, 2 > vconv_eff;

                 Array < double, 2 > exchange;

                 Array < double, 2 > qgi;

                 Array < double, 2 > flux;

                class off_diagonal {
                  public:

                    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() {

                    };
                } off_diagonal;

                int flag;
                ni_neo() {
                    flag = EMPTY_INT;

                };
            } ni_neo;

            class ne_neo {
              public:

                Array < double, 1 > diff_eff;

                 Array < double, 1 > vconv_eff;

                 Array < double, 1 > flux;

                class off_diagonal {
                  public:

                    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() {

                    };
                } off_diagonal;

                int flag;
                ne_neo() {
                    flag = EMPTY_INT;

                };
            } ne_neo;

            class nz_neo {
              public:

                Array < double, 2 > diff_eff;

                 Array < double, 2 > vconv_eff;

                 Array < double, 2 > exchange;

                 Array < double, 2 > flux;

                int flag;
                 nz_neo() {
                    flag = EMPTY_INT;

                };
            };
            Array < class nz_neo, 1 > nz_neo;

            class ti_neo {
              public:

                Array < double, 2 > diff_eff;

                 Array < double, 2 > vconv_eff;

                 Array < double, 2 > exchange;

                 Array < double, 2 > qgi;

                 Array < double, 2 > flux;

                class off_diagonal {
                  public:

                    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() {

                    };
                } off_diagonal;

                int flag;
                ti_neo() {
                    flag = EMPTY_INT;

                };
            } ti_neo;

            class te_neo {
              public:

                Array < double, 1 > diff_eff;

                 Array < double, 1 > vconv_eff;

                 Array < double, 1 > flux;

                class off_diagonal {
                  public:

                    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() {

                    };
                } off_diagonal;

                int flag;
                te_neo() {
                    flag = EMPTY_INT;

                };
            } te_neo;

            class tz_neo {
              public:

                Array < double, 2 > diff_eff;

                 Array < double, 2 > vconv_eff;

                 Array < double, 2 > exchange;

                 Array < double, 2 > flux;

                int flag;
                 tz_neo() {
                    flag = EMPTY_INT;

                };
            };
            Array < class tz_neo, 1 > tz_neo;

            class mtor_neo {
              public:

                Array < double, 1 > diff_eff;

                 Array < double, 1 > vconv_eff;

                 Array < double, 1 > flux;

                class off_diagonal {
                  public:

                    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() {

                    };
                } off_diagonal;

                int flag;
                mtor_neo() {
                    flag = EMPTY_INT;

                };
            } 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;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            neoclassic & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class com {
              public:

                double amn;

                double zion;

                 Array < double, 1 > energy;

                 Array < double, 1 > magn_mom;

                 Array < double, 1 > p_phi;

                 Array < int, 1 > sigma;
                 com() {
                    amn = EMPTY_DOUBLE;
                    zion = EMPTY_DOUBLE;

                };
            } com;

            class trace {
              public:

                Array < double, 2 > time_orb;

                 Array < int, 1 > ntorb;

                 Array < double, 2 > r;

                 Array < double, 2 > z;

                 Array < double, 2 > phi;

                 Array < double, 2 > psi;

                 Array < double, 2 > theta_b;

                 Array < double, 2 > v_parallel;

                 Array < double, 2 > v_perp;
                 trace() {

                };
            } trace;

            class global_param {
              public:

                Array < int, 1 > orbit_type;

                 Array < double, 1 > omega_b;

                 Array < double, 1 > omega_phi;

                 Array < double, 1 > omega_c_av;

                class special_pos {
                  public:

                    class midplane {
                      public:

                        class outer {
                          public:

                            Array < double, 1 > r;

                             Array < double, 1 > z;

                             Array < double, 1 > phi;

                             Array < double, 1 > psi;

                             Array < double, 1 > theta_b;
                             outer() {

                            };
                        } outer;

                        class inner {
                          public:

                            Array < double, 1 > r;

                             Array < double, 1 > z;

                             Array < double, 1 > phi;

                             Array < double, 1 > psi;

                             Array < double, 1 > theta_b;
                             inner() {

                            };
                        } inner;
                        midplane() {

                        };
                    } midplane;

                    class turning_pts {
                      public:

                        class upper {
                          public:

                            Array < double, 1 > r;

                             Array < double, 1 > z;

                             Array < double, 1 > phi;

                             Array < double, 1 > psi;

                             Array < double, 1 > theta_b;
                             upper() {

                            };
                        } upper;

                        class lower {
                          public:

                            Array < double, 1 > r;

                             Array < double, 1 > z;

                             Array < double, 1 > phi;

                             Array < double, 1 > psi;

                             Array < double, 1 > theta_b;
                             lower() {

                            };
                        } lower;
                        turning_pts() {

                        };
                    } turning_pts;
                    special_pos() {

                    };
                } special_pos;
                global_param() {

                };
            } global_param;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            orbit & operator()(int index) {
                return array(index);
            };
            orbit & operator[](int index) {
                return array(index);
            };
            int extent(int dim = 0) {
                return array.extent(dim);
            };
        };

        class pellets:Cpo {
          private:
            int expIdx;
            bool connected;
          public:
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class toroid_field {
              public:

                double r0;

                double b0;
                 toroid_field() {
                    r0 = EMPTY_DOUBLE;
                    b0 = EMPTY_DOUBLE;

                };
            } toroid_field;

            class species {
              public:

                Array < double, 1 > amn;

                 Array < double, 1 > zn;

                 Array < double, 1 > concentr;

                 Array < double, 1 > subl_energy;
                 species() {

                };
            } species;

            class shape {
              public:

                class shape_sph {
                  public:

                    double radius;
                     shape_sph() {
                        radius = EMPTY_DOUBLE;

                    };
                } shape_sph;

                class shape_cyl {
                  public:

                    double radius;

                    double height;
                     shape_cyl() {
                        radius = EMPTY_DOUBLE;
                        height = EMPTY_DOUBLE;

                    };
                } shape_cyl;
                shape() {

                };
            } shape;

            class pelletpath {
              public:

                class pivot_point {
                  public:

                    double r;

                    double z;

                    double phi;
                     pivot_point() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;
                        phi = EMPTY_DOUBLE;

                    };
                } pivot_point;

                double horchordang;

                double verchordang;

                class second_point {
                  public:

                    double r;

                    double z;

                    double phi;
                     second_point() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;
                        phi = EMPTY_DOUBLE;

                    };
                } second_point;
                pelletpath() {
                    horchordang = EMPTY_DOUBLE;
                    verchordang = EMPTY_DOUBLE;

                };
            } pelletpath;

            double velocity;

            class ablationrate {
              public:

                Array < double, 1 > rho_tor;

                 Array < double, 1 > rate;

                class position {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;

                     Array < double, 1 > phi;
                     position() {

                    };
                } position;
                ablationrate() {

                };
            } ablationrate;

            class deposprofile {
              public:

                Array < double, 1 > rho_tor;

                 Array < double, 1 > density;

                class position {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;

                     Array < double, 1 > phi;
                     position() {

                    };
                } position;

                double delay;
                deposprofile() {
                    delay = EMPTY_DOUBLE;

                };
            } deposprofile;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } codeparam;

            double time;
            pellets();
            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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            friend ostream & operator <<(ostream & os, const pellets & obj);
        };
        class pelletsArray:Cpo {
          private:
            int expIdx;
            bool connected;


          public:
             pelletsArray() {
                connected = false;
            } void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            }
            Array < pellets, 1 > array;

            int get();
            int put();
            int deleteAll();
            int deleteAll(int idx);
            int get(int idx);
            int put(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            pellets & operator()(int index) {
                return array(index);
            };
            pellets & 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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class pfcoils {
              public:

                class desc_pfcoils {
                  public:

                    Array < std::string, 1 > name;

                    Array < std::string, 1 > id;

                    Array < double, 1 > res;

                     Array < double, 1 > emax;

                     Array < int, 1 > nelement;

                    class pfelement {
                      public:

                        Array < std::string, 1 > name;

                        Array < std::string, 1 > id;

                        Array < double, 2 > turnsign;

                         Array < double, 2 > area;

                        class pfgeometry {
                          public:

                            Array < int, 2 > type;

                             Array < int, 2 > npoints;

                            class rzcoordinate {
                              public:

                                Array < double, 3 > r;

                                 Array < double, 3 > z;
                                 rzcoordinate() {

                                };
                            } rzcoordinate;

                             Array < double, 3 > rzdrdz;
                             pfgeometry() {

                            };
                        } pfgeometry;
                        pfelement() {

                        };
                    } pfelement;
                    desc_pfcoils() {

                    };
                } desc_pfcoils;

                class coilcurrent {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     coilcurrent() {

                    };
                } coilcurrent;

                class coilvoltage {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     coilvoltage() {

                    };
                } coilvoltage;
                pfcoils() {

                };
            } pfcoils;

            class pfpassive {
              public:

                Array < std::string, 1 > name;

                Array < double, 1 > area;

                 Array < double, 1 > res;

                 Array < double, 1 > eta;

                class pfpageometry {
                  public:

                    Array < int, 1 > type;

                     Array < int, 1 > npoints;

                    class rzcoordinate {
                      public:

                        Array < double, 2 > r;

                         Array < double, 2 > z;
                         rzcoordinate() {

                        };
                    } rzcoordinate;

                     Array < double, 2 > rzdrdz;
                     pfpageometry() {

                    };
                } pfpageometry;
                pfpassive() {

                };
            } pfpassive;

            class pfcircuits {
              public:

                Array < std::string, 1 > name;

                Array < std::string, 1 > id;

                Array < std::string, 1 > type;

                Array < int, 1 > nnodes;

                 Array < int, 3 > connections;
                 pfcircuits() {

                };
            } pfcircuits;

            class pfsupplies {
              public:

                class desc_supply {
                  public:

                    Array < std::string, 1 > name;

                    Array < std::string, 1 > id;

                    Array < std::string, 1 > type;

                    Array < double, 1 > delay;

                    class filter {
                      public:

                        Array < double, 2 > num;

                         Array < double, 2 > den;
                         filter() {

                        };
                    } 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() {

                    };
                } desc_supply;

                class voltage {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     voltage() {

                    };
                } voltage;

                class current {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     current() {

                    };
                } current;
                pfsupplies() {

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            pfsystems & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            std::string expression;

            class setup_line {
              public:

                class pivot_point {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;

                     Array < double, 1 > phi;
                     pivot_point() {

                    };
                } pivot_point;

                Array < double, 1 > horchordang1;

                Array < double, 1 > verchordang1;

                Array < double, 1 > width;

                class second_point {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;

                     Array < double, 1 > phi;
                     second_point() {

                    };
                } second_point;

                Array < double, 1 > horchordang2;

                Array < double, 1 > verchordang2;

                class third_point {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;

                     Array < double, 1 > phi;
                     third_point() {

                    };
                } third_point;

                int nchordpoints;
                setup_line() {
                    nchordpoints = EMPTY_INT;

                };
            } setup_line;

            class measure {
              public:

                Array < double, 1 > value;

                 Array < double, 1 > abserror;

                 Array < double, 1 > relerror;
                 measure() {

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            polardiag & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class non_timed {
              public:

                class zerod_real {
                  public:

                    class ref1 {
                      public:

                        double value;

                         std::string description;
                         ref1() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref1;

                    class ref2 {
                      public:

                        double value;

                         std::string description;
                         ref2() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref2;

                    class ref3 {
                      public:

                        double value;

                         std::string description;
                         ref3() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref3;

                    class ref4 {
                      public:

                        double value;

                         std::string description;
                         ref4() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref4;

                    class ref5 {
                      public:

                        double value;

                         std::string description;
                         ref5() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref5;

                    class ref6 {
                      public:

                        double value;

                         std::string description;
                         ref6() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref6;

                    class ref7 {
                      public:

                        double value;

                         std::string description;
                         ref7() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref7;
                    zerod_real() {

                    };
                } zerod_real;

                class zerod_int {
                  public:

                    class ref1 {
                      public:

                        int value;

                         std::string description;
                         ref1() {
                            value = EMPTY_INT;

                        };
                    } ref1;

                    class ref2 {
                      public:

                        int value;

                         std::string description;
                         ref2() {
                            value = EMPTY_INT;

                        };
                    } ref2;

                    class ref3 {
                      public:

                        int value;

                         std::string description;
                         ref3() {
                            value = EMPTY_INT;

                        };
                    } ref3;

                    class ref4 {
                      public:

                        int value;

                         std::string description;
                         ref4() {
                            value = EMPTY_INT;

                        };
                    } ref4;
                    zerod_int() {

                    };
                } zerod_int;

                class zerod_string {
                  public:

                    class ref1 {
                      public:

                        std::string value;

                        std::string description;
                        ref1() {

                        };
                    } ref1;

                    class ref2 {
                      public:

                        std::string value;

                        std::string description;
                        ref2() {

                        };
                    } ref2;
                    zerod_string() {

                    };
                } zerod_string;

                class oned_real {
                  public:

                    class ref1 {
                      public:

                        Array < double, 1 > value;

                         std::string description;
                         ref1() {

                        };
                    } ref1;

                    class ref2 {
                      public:

                        Array < double, 1 > value;

                         std::string description;
                         ref2() {

                        };
                    } ref2;

                    class ref3 {
                      public:

                        Array < double, 1 > value;

                         std::string description;
                         ref3() {

                        };
                    } ref3;

                    class ref4 {
                      public:

                        Array < double, 1 > value;

                         std::string description;
                         ref4() {

                        };
                    } ref4;

                    class ref5 {
                      public:

                        Array < double, 1 > value;

                         std::string description;
                         ref5() {

                        };
                    } ref5;
                    oned_real() {

                    };
                } oned_real;

                class oned_int {
                  public:

                    class ref1 {
                      public:

                        Array < int, 1 > value;

                         std::string description;
                         ref1() {

                        };
                    } ref1;

                    class ref2 {
                      public:

                        Array < int, 1 > value;

                         std::string description;
                         ref2() {

                        };
                    } ref2;

                    class ref3 {
                      public:

                        Array < int, 1 > value;

                         std::string description;
                         ref3() {

                        };
                    } ref3;

                    class ref4 {
                      public:

                        Array < int, 1 > value;

                         std::string description;
                         ref4() {

                        };
                    } ref4;
                    oned_int() {

                    };
                } oned_int;
                non_timed() {

                };
            } non_timed;

            class timed {
              public:

                class zerod_real {
                  public:

                    class ref1 {
                      public:

                        double value;

                         std::string description;
                         ref1() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref1;

                    class ref2 {
                      public:

                        double value;

                         std::string description;
                         ref2() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref2;

                    class ref3 {
                      public:

                        double value;

                         std::string description;
                         ref3() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref3;

                    class ref4 {
                      public:

                        double value;

                         std::string description;
                         ref4() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref4;

                    class ref5 {
                      public:

                        double value;

                         std::string description;
                         ref5() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref5;

                    class ref6 {
                      public:

                        double value;

                         std::string description;
                         ref6() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref6;

                    class ref7 {
                      public:

                        double value;

                         std::string description;
                         ref7() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref7;

                    class ref8 {
                      public:

                        double value;

                         std::string description;
                         ref8() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref8;

                    class ref9 {
                      public:

                        double value;

                         std::string description;
                         ref9() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref9;

                    class ref10 {
                      public:

                        double value;

                         std::string description;
                         ref10() {
                            value = EMPTY_DOUBLE;

                        };
                    } ref10;
                    zerod_real() {

                    };
                } zerod_real;

                class zerod_int {
                  public:

                    class ref1 {
                      public:

                        int value;

                         std::string description;
                         ref1() {
                            value = EMPTY_INT;

                        };
                    } ref1;

                    class ref2 {
                      public:

                        int value;

                         std::string description;
                         ref2() {
                            value = EMPTY_INT;

                        };
                    } ref2;

                    class ref3 {
                      public:

                        int value;

                         std::string description;
                         ref3() {
                            value = EMPTY_INT;

                        };
                    } ref3;

                    class ref4 {
                      public:

                        int value;

                         std::string description;
                         ref4() {
                            value = EMPTY_INT;

                        };
                    } ref4;
                    zerod_int() {

                    };
                } zerod_int;

                class oned_real {
                  public:

                    class ref1 {
                      public:

                        Array < double, 1 > value;

                         std::string description;
                         ref1() {

                        };
                    } ref1;

                    class ref2 {
                      public:

                        Array < double, 1 > value;

                         std::string description;
                         ref2() {

                        };
                    } ref2;

                    class ref3 {
                      public:

                        Array < double, 1 > value;

                         std::string description;
                         ref3() {

                        };
                    } ref3;

                    class ref4 {
                      public:

                        Array < double, 1 > value;

                         std::string description;
                         ref4() {

                        };
                    } ref4;

                    class ref5 {
                      public:

                        Array < double, 1 > value;

                         std::string description;
                         ref5() {

                        };
                    } ref5;
                    oned_real() {

                    };
                } oned_real;

                class oned_int {
                  public:

                    class ref1 {
                      public:

                        Array < int, 1 > value;

                         std::string description;
                         ref1() {

                        };
                    } ref1;

                    class ref2 {
                      public:

                        Array < int, 1 > value;

                         std::string description;
                         ref2() {

                        };
                    } ref2;

                    class ref3 {
                      public:

                        Array < int, 1 > value;

                         std::string description;
                         ref3() {

                        };
                    } ref3;

                    class ref4 {
                      public:

                        Array < int, 1 > value;

                         std::string description;
                         ref4() {

                        };
                    } ref4;
                    oned_int() {

                    };
                } oned_int;
                timed() {

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            reference & operator()(int index) {
                return array(index);
            };
            reference & operator[](int index) {
                return array(index);
            };
            int extent(int dim = 0) {
                return array.extent(dim);
            };
        };

        class rfadiag:Cpo {
          private:
            int expIdx;
            bool connected;
          public:
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class setup {
              public:

                class position {
                  public:

                    class r {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         r() {

                        };
                    } r;

                    class z {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         z() {

                        };
                    } z;

                    class phi {
                      public:

                        Array < double, 1 > value;

                         Array < double, 1 > abserror;

                         Array < double, 1 > relerror;
                         phi() {

                        };
                    } phi;
                    position() {

                    };
                } position;
                setup() {

                };
            } setup;

            class measure {
              public:

                class ti {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     ti() {

                    };
                } ti;
                measure() {

                };
            } measure;

            double time;
            rfadiag();
            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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            friend ostream & operator <<(ostream & os, const rfadiag & obj);
        };
        class rfadiagArray:Cpo {
          private:
            int expIdx;
            bool connected;


          public:
             rfadiagArray() {
                connected = false;
            } void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            }
            Array < rfadiag, 1 > array;

            int get();
            int put();
            int deleteAll();
            int deleteAll(int idx);
            int get(int idx);
            int put(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            rfadiag & operator()(int index) {
                return array(index);
            };
            rfadiag & 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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            int crash_trig;

            class composition {
              public:

                Array < double, 1 > amn;

                 Array < double, 1 > zn;

                 Array < double, 1 > zion;

                 Array < int, 1 > imp_flag;

                 Array < std::string, 1 > label;
                 composition() {

                };
            } composition;

            Array < double, 1 > rho_tor_norm;

            Array < double, 1 > rho_tor;

            class profiles1d {
              public:

                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() {

                };
            } profiles1d;

            class diags {
              public:

                double shear1;

                double rhotorn_q1;

                double rhotorn_inv;

                double rhotorn_mix;
                 diags() {
                    shear1 = EMPTY_DOUBLE;
                    rhotorn_q1 = EMPTY_DOUBLE;
                    rhotorn_inv = EMPTY_DOUBLE;
                    rhotorn_mix = EMPTY_DOUBLE;

                };
            } diags;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            sawteeth & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class centre {
              public:

                class te0 {
                  public:

                    double value;

                     std::string source;
                     te0() {
                        value = EMPTY_DOUBLE;

                    };
                } te0;

                class ti0 {
                  public:

                    double value;

                     std::string source;
                     ti0() {
                        value = EMPTY_DOUBLE;

                    };
                } ti0;

                class ne0 {
                  public:

                    double value;

                     std::string source;
                     ne0() {
                        value = EMPTY_DOUBLE;

                    };
                } ne0;

                class ni0 {
                  public:

                    double value;

                     std::string source;
                     ni0() {
                        value = EMPTY_DOUBLE;

                    };
                } ni0;

                class shift0 {
                  public:

                    double value;

                     std::string source;
                     shift0() {
                        value = EMPTY_DOUBLE;

                    };
                } shift0;

                class psi0 {
                  public:

                    double value;

                     std::string source;
                     psi0() {
                        value = EMPTY_DOUBLE;

                    };
                } psi0;

                class phi0 {
                  public:

                    double value;

                     std::string source;
                     phi0() {
                        value = EMPTY_DOUBLE;

                    };
                } phi0;

                class q0 {
                  public:

                    double value;

                     std::string source;
                     q0() {
                        value = EMPTY_DOUBLE;

                    };
                } q0;

                class Rmag {
                  public:

                    double value;

                     std::string source;
                     Rmag() {
                        value = EMPTY_DOUBLE;

                    };
                } Rmag;

                class Zmag {
                  public:

                    double value;

                     std::string source;
                     Zmag() {
                        value = EMPTY_DOUBLE;

                    };
                } Zmag;

                class vtor_0 {
                  public:

                    double value;

                     std::string source;
                     vtor_0() {
                        value = EMPTY_DOUBLE;

                    };
                } vtor_0;
                centre() {

                };
            } centre;

            class composition {
              public:

                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() {

                };
            } composition;

            class configs {
              public:

                class config {
                  public:

                    int value;

                     std::string source;
                     config() {
                        value = EMPTY_INT;

                    };
                } 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;

                class ecrh_freq {
                  public:

                    double value;

                     std::string source;
                     ecrh_freq() {
                        value = EMPTY_DOUBLE;

                    };
                } ecrh_freq;

                class ecrh_loc {
                  public:

                    double value;

                     std::string source;
                     ecrh_loc() {
                        value = EMPTY_DOUBLE;

                    };
                } ecrh_loc;

                class ecrh_mode {
                  public:

                    int value;

                     std::string source;
                     ecrh_mode() {
                        value = EMPTY_INT;

                    };
                } ecrh_mode;

                class ecrh_tor_ang {
                  public:

                    double value;

                     std::string source;
                     ecrh_tor_ang() {
                        value = EMPTY_DOUBLE;

                    };
                } ecrh_tor_ang;

                class ecrh_pol_ang {
                  public:

                    double value;

                     std::string source;
                     ecrh_pol_ang() {
                        value = EMPTY_DOUBLE;

                    };
                } ecrh_pol_ang;

                class ecrh_harm {
                  public:

                    int value;

                     std::string source;
                     ecrh_harm() {
                        value = EMPTY_INT;

                    };
                } ecrh_harm;

                class enbi {
                  public:

                    double value;

                     std::string source;
                     enbi() {
                        value = EMPTY_DOUBLE;

                    };
                } enbi;

                class r_nbi {
                  public:

                    double value;

                     std::string source;
                     r_nbi() {
                        value = EMPTY_DOUBLE;

                    };
                } r_nbi;

                class grad_b_drift {
                  public:

                    int value;

                     std::string source;
                     grad_b_drift() {
                        value = EMPTY_INT;

                    };
                } grad_b_drift;

                class icrh_freq {
                  public:

                    double value;

                     std::string source;
                     icrh_freq() {
                        value = EMPTY_DOUBLE;

                    };
                } icrh_freq;

                std::string icrh_scheme;

                class icrh_phase {
                  public:

                    double value;

                     std::string source;
                     icrh_phase() {
                        value = EMPTY_DOUBLE;

                    };
                } icrh_phase;

                class LH_freq {
                  public:

                    double value;

                     std::string source;
                     LH_freq() {
                        value = EMPTY_DOUBLE;

                    };
                } LH_freq;

                class LH_npar {
                  public:

                    double value;

                     std::string source;
                     LH_npar() {
                        value = EMPTY_DOUBLE;

                    };
                } LH_npar;

                class pellet_ang {
                  public:

                    double value;

                     std::string source;
                     pellet_ang() {
                        value = EMPTY_DOUBLE;

                    };
                } pellet_ang;

                class pellet_v {
                  public:

                    double value;

                     std::string source;
                     pellet_v() {
                        value = EMPTY_DOUBLE;

                    };
                } pellet_v;

                class pellet_nba {
                  public:

                    double value;

                     std::string source;
                     pellet_nba() {
                        value = EMPTY_DOUBLE;

                    };
                } pellet_nba;
                configs() {

                };
            } configs;

            class confinement {
              public:

                class tau_e {
                  public:

                    double value;

                     std::string source;
                     tau_e() {
                        value = EMPTY_DOUBLE;

                    };
                } tau_e;

                class tau_l_sc {
                  public:

                    double value;

                     std::string source;
                     tau_l_sc() {
                        value = EMPTY_DOUBLE;

                    };
                } tau_l_sc;

                class tau_h_sc {
                  public:

                    double value;

                     std::string source;
                     tau_h_sc() {
                        value = EMPTY_DOUBLE;

                    };
                } tau_h_sc;

                class tau_he {
                  public:

                    double value;

                     std::string source;
                     tau_he() {
                        value = EMPTY_DOUBLE;

                    };
                } tau_he;

                class tau_e_ee {
                  public:

                    double value;

                     std::string source;
                     tau_e_ee() {
                        value = EMPTY_DOUBLE;

                    };
                } tau_e_ee;

                class tau_e_ii {
                  public:

                    double value;

                     std::string source;
                     tau_e_ii() {
                        value = EMPTY_DOUBLE;

                    };
                } tau_e_ii;

                class tau_e_ei {
                  public:

                    double value;

                     std::string source;
                     tau_e_ei() {
                        value = EMPTY_DOUBLE;

                    };
                } tau_e_ei;

                class tau_cur_diff {
                  public:

                    double value;

                     std::string source;
                     tau_cur_diff() {
                        value = EMPTY_DOUBLE;

                    };
                } tau_cur_diff;

                class tau_i_rol {
                  public:

                    double value;

                     std::string source;
                     tau_i_rol() {
                        value = EMPTY_DOUBLE;

                    };
                } tau_i_rol;
                confinement() {

                };
            } confinement;

            class currents {
              public:

                class RR {
                  public:

                    double value;

                     std::string source;
                     RR() {
                        value = EMPTY_DOUBLE;

                    };
                } RR;

                class i_align {
                  public:

                    double value;

                     std::string source;
                     i_align() {
                        value = EMPTY_DOUBLE;

                    };
                } i_align;

                class i_boot {
                  public:

                    double value;

                     std::string source;
                     i_boot() {
                        value = EMPTY_DOUBLE;

                    };
                } i_boot;

                class i_cd_tot {
                  public:

                    double value;

                     std::string source;
                     i_cd_tot() {
                        value = EMPTY_DOUBLE;

                    };
                } i_cd_tot;

                class i_eccd {
                  public:

                    double value;

                     std::string source;
                     i_eccd() {
                        value = EMPTY_DOUBLE;

                    };
                } i_eccd;

                class i_fast_ion {
                  public:

                    double value;

                     std::string source;
                     i_fast_ion() {
                        value = EMPTY_DOUBLE;

                    };
                } i_fast_ion;

                class i_fwcd {
                  public:

                    double value;

                     std::string source;
                     i_fwcd() {
                        value = EMPTY_DOUBLE;

                    };
                } i_fwcd;

                class i_lhcd {
                  public:

                    double value;

                     std::string source;
                     i_lhcd() {
                        value = EMPTY_DOUBLE;

                    };
                } i_lhcd;

                class i_nbicd {
                  public:

                    double value;

                     std::string source;
                     i_nbicd() {
                        value = EMPTY_DOUBLE;

                    };
                } i_nbicd;

                class i_ni_tot {
                  public:

                    double value;

                     std::string source;
                     i_ni_tot() {
                        value = EMPTY_DOUBLE;

                    };
                } i_ni_tot;

                class i_ohm {
                  public:

                    double value;

                     std::string source;
                     i_ohm() {
                        value = EMPTY_DOUBLE;

                    };
                } i_ohm;

                class i_par {
                  public:

                    double value;

                     std::string source;
                     i_par() {
                        value = EMPTY_DOUBLE;

                    };
                } i_par;

                class i_runaway {
                  public:

                    double value;

                     std::string source;
                     i_runaway() {
                        value = EMPTY_DOUBLE;

                    };
                } i_runaway;

                class v_loop {
                  public:

                    double value;

                     std::string source;
                     v_loop() {
                        value = EMPTY_DOUBLE;

                    };
                } v_loop;

                class v_meas {
                  public:

                    double value;

                     std::string source;
                     v_meas() {
                        value = EMPTY_DOUBLE;

                    };
                } v_meas;
                currents() {

                };
            } currents;

            class edge {
              public:

                class te_edge {
                  public:

                    double value;

                     std::string source;
                     te_edge() {
                        value = EMPTY_DOUBLE;

                    };
                } te_edge;

                class ti_edge {
                  public:

                    double value;

                     std::string source;
                     ti_edge() {
                        value = EMPTY_DOUBLE;

                    };
                } ti_edge;

                class ne_edge {
                  public:

                    double value;

                     std::string source;
                     ne_edge() {
                        value = EMPTY_DOUBLE;

                    };
                } ne_edge;

                class ni_edge {
                  public:

                    double value;

                     std::string source;
                     ni_edge() {
                        value = EMPTY_DOUBLE;

                    };
                } ni_edge;

                class psi_edge {
                  public:

                    double value;

                     std::string source;
                     psi_edge() {
                        value = EMPTY_DOUBLE;

                    };
                } psi_edge;

                class phi_edge {
                  public:

                    double value;

                     std::string source;
                     phi_edge() {
                        value = EMPTY_DOUBLE;

                    };
                } phi_edge;

                class rho_edge {
                  public:

                    double value;

                     std::string source;
                     rho_edge() {
                        value = EMPTY_DOUBLE;

                    };
                } rho_edge;

                class drho_edge_dt {
                  public:

                    double value;

                     std::string source;
                     drho_edge_dt() {
                        value = EMPTY_DOUBLE;

                    };
                } drho_edge_dt;

                class q_edge {
                  public:

                    double value;

                     std::string source;
                     q_edge() {
                        value = EMPTY_DOUBLE;

                    };
                } q_edge;

                class neutral_flux {
                  public:

                    double value;

                     std::string source;
                     neutral_flux() {
                        value = EMPTY_DOUBLE;

                    };
                } neutral_flux;

                class phi_plasma {
                  public:

                    double value;

                     std::string source;
                     phi_plasma() {
                        value = EMPTY_DOUBLE;

                    };
                } phi_plasma;

                class vtor_edge {
                  public:

                    double value;

                     std::string source;
                     vtor_edge() {
                        value = EMPTY_DOUBLE;

                    };
                } vtor_edge;
                edge() {

                };
            } edge;

            class energy {
              public:

                class w_tot {
                  public:

                    double value;

                     std::string source;
                     w_tot() {
                        value = EMPTY_DOUBLE;

                    };
                } w_tot;

                class w_b_pol {
                  public:

                    double value;

                     std::string source;
                     w_b_pol() {
                        value = EMPTY_DOUBLE;

                    };
                } w_b_pol;

                class w_dia {
                  public:

                    double value;

                     std::string source;
                     w_dia() {
                        value = EMPTY_DOUBLE;

                    };
                } w_dia;

                class dwdia_dt {
                  public:

                    double value;

                     std::string source;
                     dwdia_dt() {
                        value = EMPTY_DOUBLE;

                    };
                } dwdia_dt;

                class w_b_tor_pla {
                  public:

                    double value;

                     std::string source;
                     w_b_tor_pla() {
                        value = EMPTY_DOUBLE;

                    };
                } w_b_tor_pla;

                class w_th {
                  public:

                    double value;

                     std::string source;
                     w_th() {
                        value = EMPTY_DOUBLE;

                    };
                } w_th;

                class dwtot_dt {
                  public:

                    double value;

                     std::string source;
                     dwtot_dt() {
                        value = EMPTY_DOUBLE;

                    };
                } dwtot_dt;

                class dwbpol_dt {
                  public:

                    double value;

                     std::string source;
                     dwbpol_dt() {
                        value = EMPTY_DOUBLE;

                    };
                } dwbpol_dt;

                class dwbtorpla_dt {
                  public:

                    double value;

                     std::string source;
                     dwbtorpla_dt() {
                        value = EMPTY_DOUBLE;

                    };
                } dwbtorpla_dt;

                class dwth_dt {
                  public:

                    double value;

                     std::string source;
                     dwth_dt() {
                        value = EMPTY_DOUBLE;

                    };
                } dwth_dt;

                class esup_icrhtot {
                  public:

                    double value;

                     std::string source;
                     esup_icrhtot() {
                        value = EMPTY_DOUBLE;

                    };
                } esup_icrhtot;

                class esup_icrhper {
                  public:

                    double value;

                     std::string source;
                     esup_icrhper() {
                        value = EMPTY_DOUBLE;

                    };
                } esup_icrhper;

                class esup_nbitot {
                  public:

                    double value;

                     std::string source;
                     esup_nbitot() {
                        value = EMPTY_DOUBLE;

                    };
                } esup_nbitot;

                class esup_nbiperp {
                  public:

                    double value;

                     std::string source;
                     esup_nbiperp() {
                        value = EMPTY_DOUBLE;

                    };
                } esup_nbiperp;

                class esup_lhcd {
                  public:

                    double value;

                     std::string source;
                     esup_lhcd() {
                        value = EMPTY_DOUBLE;

                    };
                } esup_lhcd;

                class esup_alpha {
                  public:

                    double value;

                     std::string source;
                     esup_alpha() {
                        value = EMPTY_DOUBLE;

                    };
                } esup_alpha;
                energy() {

                };
            } energy;

            class eqgeometry {
              public:

                std::string source;

                int boundarytype;

                class boundary {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;
                     boundary() {

                    };
                };
                Array < class boundary, 1 > boundary;

                class geom_axis {
                  public:

                    double r;

                    double z;
                     geom_axis() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;

                    };
                } geom_axis;

                double a_minor;

                double elongation;

                double elong_upper;

                double elong_lower;

                double tria_upper;

                double tria_lower;

                class xpts {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;
                     xpts() {

                    };
                };
                Array < class xpts, 1 > xpts;

                class left_low_st {
                  public:

                    double r;

                    double z;
                     left_low_st() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;

                    };
                } left_low_st;

                class right_low_st {
                  public:

                    double r;

                    double z;
                     right_low_st() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;

                    };
                } right_low_st;

                class left_up_st {
                  public:

                    double r;

                    double z;
                     left_up_st() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;

                    };
                } left_up_st;

                class right_up_st {
                  public:

                    double r;

                    double z;
                     right_up_st() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;

                    };
                } right_up_st;

                class active_limit {
                  public:

                    double r;

                    double z;
                     active_limit() {
                        r = EMPTY_DOUBLE;
                        z = EMPTY_DOUBLE;

                    };
                } active_limit;

                double ang_lcms_upo;

                double ang_lcms_upi;

                double ang_lcms_lwo;

                double ang_lcms_lwi;
                eqgeometry() {
                    boundarytype = EMPTY_INT;
                    a_minor = EMPTY_DOUBLE;
                    elongation = EMPTY_DOUBLE;
                    elong_upper = EMPTY_DOUBLE;
                    elong_lower = EMPTY_DOUBLE;
                    tria_upper = EMPTY_DOUBLE;
                    tria_lower = EMPTY_DOUBLE;
                    ang_lcms_upo = EMPTY_DOUBLE;
                    ang_lcms_upi = EMPTY_DOUBLE;
                    ang_lcms_lwo = EMPTY_DOUBLE;
                    ang_lcms_lwi = EMPTY_DOUBLE;

                };
            } eqgeometry;

            class global_param {
              public:

                class ip {
                  public:

                    double value;

                     std::string source;
                     ip() {
                        value = EMPTY_DOUBLE;

                    };
                } ip;

                class dip_dt {
                  public:

                    double value;

                     std::string source;
                     dip_dt() {
                        value = EMPTY_DOUBLE;

                    };
                } dip_dt;

                class beta_pol {
                  public:

                    double value;

                     std::string source;
                     beta_pol() {
                        value = EMPTY_DOUBLE;

                    };
                } beta_pol;

                class beta_tor {
                  public:

                    double value;

                     std::string source;
                     beta_tor() {
                        value = EMPTY_DOUBLE;

                    };
                } beta_tor;

                class beta_normal {
                  public:

                    double value;

                     std::string source;
                     beta_normal() {
                        value = EMPTY_DOUBLE;

                    };
                } beta_normal;

                class li {
                  public:

                    double value;

                     std::string source;
                     li() {
                        value = EMPTY_DOUBLE;

                    };
                } li;

                class volume {
                  public:

                    double value;

                     std::string source;
                     volume() {
                        value = EMPTY_DOUBLE;

                    };
                } volume;

                class area_pol {
                  public:

                    double value;

                     std::string source;
                     area_pol() {
                        value = EMPTY_DOUBLE;

                    };
                } area_pol;

                class area_ext {
                  public:

                    double value;

                     std::string source;
                     area_ext() {
                        value = EMPTY_DOUBLE;

                    };
                } area_ext;

                class len_sepa {
                  public:

                    double value;

                     std::string source;
                     len_sepa() {
                        value = EMPTY_DOUBLE;

                    };
                } len_sepa;

                class beta_pol_th {
                  public:

                    double value;

                     std::string source;
                     beta_pol_th() {
                        value = EMPTY_DOUBLE;

                    };
                } beta_pol_th;

                class beta_tor_th {
                  public:

                    double value;

                     std::string source;
                     beta_tor_th() {
                        value = EMPTY_DOUBLE;

                    };
                } beta_tor_th;

                class beta_n_th {
                  public:

                    double value;

                     std::string source;
                     beta_n_th() {
                        value = EMPTY_DOUBLE;

                    };
                } beta_n_th;

                class disruption {
                  public:

                    double value;

                     std::string source;
                     disruption() {
                        value = EMPTY_DOUBLE;

                    };
                } disruption;

                class mode_h {
                  public:

                    double value;

                     std::string source;
                     mode_h() {
                        value = EMPTY_DOUBLE;

                    };
                } mode_h;

                class s_alpha {
                  public:

                    double value;

                     std::string source;
                     s_alpha() {
                        value = EMPTY_DOUBLE;

                    };
                } s_alpha;
                global_param() {

                };
            } global_param;

            class heat_power {
              public:

                class plh {
                  public:

                    double value;

                     std::string source;
                     plh() {
                        value = EMPTY_DOUBLE;

                    };
                } plh;

                class pohmic {
                  public:

                    double value;

                     std::string source;
                     pohmic() {
                        value = EMPTY_DOUBLE;

                    };
                } pohmic;

                class picrh {
                  public:

                    double value;

                     std::string source;
                     picrh() {
                        value = EMPTY_DOUBLE;

                    };
                } picrh;

                class pecrh {
                  public:

                    double value;

                     std::string source;
                     pecrh() {
                        value = EMPTY_DOUBLE;

                    };
                } pecrh;

                class pnbi {
                  public:

                    double value;

                     std::string source;
                     pnbi() {
                        value = EMPTY_DOUBLE;

                    };
                } pnbi;

                class pnbi_co_cur {
                  public:

                    double value;

                     std::string source;
                     pnbi_co_cur() {
                        value = EMPTY_DOUBLE;

                    };
                } pnbi_co_cur;

                class pnbi_counter {
                  public:

                    double value;

                     std::string source;
                     pnbi_counter() {
                        value = EMPTY_DOUBLE;

                    };
                } pnbi_counter;

                class plh_th {
                  public:

                    double value;

                     std::string source;
                     plh_th() {
                        value = EMPTY_DOUBLE;

                    };
                } plh_th;

                class picrh_th {
                  public:

                    double value;

                     std::string source;
                     picrh_th() {
                        value = EMPTY_DOUBLE;

                    };
                } picrh_th;

                class pecrh_th {
                  public:

                    double value;

                     std::string source;
                     pecrh_th() {
                        value = EMPTY_DOUBLE;

                    };
                } pecrh_th;

                class pnbi_th {
                  public:

                    double value;

                     std::string source;
                     pnbi_th() {
                        value = EMPTY_DOUBLE;

                    };
                } pnbi_th;

                class ploss_icrh {
                  public:

                    double value;

                     std::string source;
                     ploss_icrh() {
                        value = EMPTY_DOUBLE;

                    };
                } ploss_icrh;

                class ploss_nbi {
                  public:

                    double value;

                     std::string source;
                     ploss_nbi() {
                        value = EMPTY_DOUBLE;

                    };
                } ploss_nbi;

                class pbrem {
                  public:

                    double value;

                     std::string source;
                     pbrem() {
                        value = EMPTY_DOUBLE;

                    };
                } pbrem;

                class pcyclo {
                  public:

                    double value;

                     std::string source;
                     pcyclo() {
                        value = EMPTY_DOUBLE;

                    };
                } pcyclo;

                class prad {
                  public:

                    double value;

                     std::string source;
                     prad() {
                        value = EMPTY_DOUBLE;

                    };
                } prad;

                class pdd_fus {
                  public:

                    double value;

                     std::string source;
                     pdd_fus() {
                        value = EMPTY_DOUBLE;

                    };
                } pdd_fus;

                class pei {
                  public:

                    double value;

                     std::string source;
                     pei() {
                        value = EMPTY_DOUBLE;

                    };
                } pei;

                class pel_tot {
                  public:

                    double value;

                     std::string source;
                     pel_tot() {
                        value = EMPTY_DOUBLE;

                    };
                } pel_tot;

                class pel_fus {
                  public:

                    double value;

                     std::string source;
                     pel_fus() {
                        value = EMPTY_DOUBLE;

                    };
                } pel_fus;

                class pel_icrh {
                  public:

                    double value;

                     std::string source;
                     pel_icrh() {
                        value = EMPTY_DOUBLE;

                    };
                } pel_icrh;

                class pel_nbi {
                  public:

                    double value;

                     std::string source;
                     pel_nbi() {
                        value = EMPTY_DOUBLE;

                    };
                } pel_nbi;

                class pfus_dt {
                  public:

                    double value;

                     std::string source;
                     pfus_dt() {
                        value = EMPTY_DOUBLE;

                    };
                } pfus_dt;

                class ploss_fus {
                  public:

                    double value;

                     std::string source;
                     ploss_fus() {
                        value = EMPTY_DOUBLE;

                    };
                } ploss_fus;

                class pfus_nbi {
                  public:

                    double value;

                     std::string source;
                     pfus_nbi() {
                        value = EMPTY_DOUBLE;

                    };
                } pfus_nbi;

                class pfus_th {
                  public:

                    double value;

                     std::string source;
                     pfus_th() {
                        value = EMPTY_DOUBLE;

                    };
                } pfus_th;

                class padd_tot {
                  public:

                    double value;

                     std::string source;
                     padd_tot() {
                        value = EMPTY_DOUBLE;

                    };
                } padd_tot;

                class pion_tot {
                  public:

                    double value;

                     std::string source;
                     pion_tot() {
                        value = EMPTY_DOUBLE;

                    };
                } pion_tot;

                class pion_fus {
                  public:

                    double value;

                     std::string source;
                     pion_fus() {
                        value = EMPTY_DOUBLE;

                    };
                } pion_fus;

                class pion_icrh {
                  public:

                    double value;

                     std::string source;
                     pion_icrh() {
                        value = EMPTY_DOUBLE;

                    };
                } pion_icrh;

                class pion_nbi {
                  public:

                    double value;

                     std::string source;
                     pion_nbi() {
                        value = EMPTY_DOUBLE;

                    };
                } pion_nbi;

                class pioniz {
                  public:

                    double value;

                     std::string source;
                     pioniz() {
                        value = EMPTY_DOUBLE;

                    };
                } pioniz;

                class ploss {
                  public:

                    double value;

                     std::string source;
                     ploss() {
                        value = EMPTY_DOUBLE;

                    };
                } ploss;

                class p_wth {
                  public:

                    double value;

                     std::string source;
                     p_wth() {
                        value = EMPTY_DOUBLE;

                    };
                } p_wth;

                class p_w {
                  public:

                    double value;

                     std::string source;
                     p_w() {
                        value = EMPTY_DOUBLE;

                    };
                } p_w;

                class p_l2h_thr {
                  public:

                    double value;

                     std::string source;
                     p_l2h_thr() {
                        value = EMPTY_DOUBLE;

                    };
                } p_l2h_thr;

                class p_l2h_sc {
                  public:

                    double value;

                     std::string source;
                     p_l2h_sc() {
                        value = EMPTY_DOUBLE;

                    };
                } p_l2h_sc;

                class p_nbi_icrh {
                  public:

                    double value;

                     std::string source;
                     p_nbi_icrh() {
                        value = EMPTY_DOUBLE;

                    };
                } p_nbi_icrh;
                heat_power() {

                };
            } heat_power;

            class itb {
              public:

                class q_min {
                  public:

                    double value;

                     std::string source;
                     q_min() {
                        value = EMPTY_DOUBLE;

                    };
                } q_min;

                class te_itb {
                  public:

                    double value;

                     std::string source;
                     te_itb() {
                        value = EMPTY_DOUBLE;

                    };
                } te_itb;

                class ti_itb {
                  public:

                    double value;

                     std::string source;
                     ti_itb() {
                        value = EMPTY_DOUBLE;

                    };
                } ti_itb;

                class ne_itb {
                  public:

                    double value;

                     std::string source;
                     ne_itb() {
                        value = EMPTY_DOUBLE;

                    };
                } ne_itb;

                class ni_itb {
                  public:

                    double value;

                     std::string source;
                     ni_itb() {
                        value = EMPTY_DOUBLE;

                    };
                } ni_itb;

                class psi_itb {
                  public:

                    double value;

                     std::string source;
                     psi_itb() {
                        value = EMPTY_DOUBLE;

                    };
                } psi_itb;

                class phi_itb {
                  public:

                    double value;

                     std::string source;
                     phi_itb() {
                        value = EMPTY_DOUBLE;

                    };
                } phi_itb;

                class rho_itb {
                  public:

                    double value;

                     std::string source;
                     rho_itb() {
                        value = EMPTY_DOUBLE;

                    };
                } rho_itb;

                class h_itb {
                  public:

                    double value;

                     std::string source;
                     h_itb() {
                        value = EMPTY_DOUBLE;

                    };
                } h_itb;

                class width_itb {
                  public:

                    double value;

                     std::string source;
                     width_itb() {
                        value = EMPTY_DOUBLE;

                    };
                } width_itb;

                class vtor_itb {
                  public:

                    double value;

                     std::string source;
                     vtor_itb() {
                        value = EMPTY_DOUBLE;

                    };
                } vtor_itb;

                class itb_type {
                  public:

                    int value;

                     std::string source;
                     itb_type() {
                        value = EMPTY_INT;

                    };
                } itb_type;
                itb() {

                };
            } itb;

            class lim_div_wall {
              public:

                class te_lim_div {
                  public:

                    double value;

                     std::string source;
                     te_lim_div() {
                        value = EMPTY_DOUBLE;

                    };
                } te_lim_div;

                class ti_lim_div {
                  public:

                    double value;

                     std::string source;
                     ti_lim_div() {
                        value = EMPTY_DOUBLE;

                    };
                } ti_lim_div;

                class ne_lim_div {
                  public:

                    double value;

                     std::string source;
                     ne_lim_div() {
                        value = EMPTY_DOUBLE;

                    };
                } ne_lim_div;

                class ni_lim_div {
                  public:

                    double value;

                     std::string source;
                     ni_lim_div() {
                        value = EMPTY_DOUBLE;

                    };
                } ni_lim_div;

                class p_peak_div {
                  public:

                    double value;

                     std::string source;
                     p_peak_div() {
                        value = EMPTY_DOUBLE;

                    };
                } p_peak_div;

                class surf_temp {
                  public:

                    double value;

                     std::string source;
                     surf_temp() {
                        value = EMPTY_DOUBLE;

                    };
                } surf_temp;

                class p_lim_div {
                  public:

                    double value;

                     std::string source;
                     p_lim_div() {
                        value = EMPTY_DOUBLE;

                    };
                } p_lim_div;

                class p_rad_div {
                  public:

                    double value;

                     std::string source;
                     p_rad_div() {
                        value = EMPTY_DOUBLE;

                    };
                } p_rad_div;

                class wall_temp {
                  public:

                    double value;

                     std::string source;
                     wall_temp() {
                        value = EMPTY_DOUBLE;

                    };
                } wall_temp;

                class wall_state {
                  public:

                    double value;

                     std::string source;
                     wall_state() {
                        value = EMPTY_DOUBLE;

                    };
                } wall_state;

                class detach_state {
                  public:

                    double value;

                     std::string source;
                     detach_state() {
                        value = EMPTY_DOUBLE;

                    };
                } detach_state;

                class pump_flux {
                  public:

                    double value;

                     std::string source;
                     pump_flux() {
                        value = EMPTY_DOUBLE;

                    };
                } pump_flux;
                lim_div_wall() {

                };
            } lim_div_wall;

            class line_ave {
              public:

                class ne_line {
                  public:

                    double value;

                     std::string source;
                     ne_line() {
                        value = EMPTY_DOUBLE;

                    };
                } ne_line;

                class zeff_line {
                  public:

                    double value;

                     std::string source;
                     zeff_line() {
                        value = EMPTY_DOUBLE;

                    };
                } zeff_line;

                class ne_zeff_line {
                  public:

                    double value;

                     std::string source;
                     ne_zeff_line() {
                        value = EMPTY_DOUBLE;

                    };
                } ne_zeff_line;

                class dne_line_dt {
                  public:

                    double value;

                     std::string source;
                     dne_line_dt() {
                        value = EMPTY_DOUBLE;

                    };
                } dne_line_dt;
                line_ave() {

                };
            } line_ave;

            class neutron {
              public:

                class ndd_tot {
                  public:

                    double value;

                     std::string source;
                     ndd_tot() {
                        value = EMPTY_DOUBLE;

                    };
                } ndd_tot;

                class ndd_th {
                  public:

                    double value;

                     std::string source;
                     ndd_th() {
                        value = EMPTY_DOUBLE;

                    };
                } ndd_th;

                class ndd_nbi_th {
                  public:

                    double value;

                     std::string source;
                     ndd_nbi_th() {
                        value = EMPTY_DOUBLE;

                    };
                } ndd_nbi_th;

                class ndd_nbi_nbi {
                  public:

                    double value;

                     std::string source;
                     ndd_nbi_nbi() {
                        value = EMPTY_DOUBLE;

                    };
                } ndd_nbi_nbi;

                class ndt_tot {
                  public:

                    double value;

                     std::string source;
                     ndt_tot() {
                        value = EMPTY_DOUBLE;

                    };
                } ndt_tot;

                class ndt_th {
                  public:

                    double value;

                     std::string source;
                     ndt_th() {
                        value = EMPTY_DOUBLE;

                    };
                } ndt_th;
                neutron() {

                };
            } neutron;

            class ninety_five {
              public:

                class q_95 {
                  public:

                    double value;

                     std::string source;
                     q_95() {
                        value = EMPTY_DOUBLE;

                    };
                } q_95;

                class elong_95 {
                  public:

                    double value;

                     std::string source;
                     elong_95() {
                        value = EMPTY_DOUBLE;

                    };
                } elong_95;

                class tria_95 {
                  public:

                    double value;

                     std::string source;
                     tria_95() {
                        value = EMPTY_DOUBLE;

                    };
                } tria_95;

                class tria_up_95 {
                  public:

                    double value;

                     std::string source;
                     tria_up_95() {
                        value = EMPTY_DOUBLE;

                    };
                } tria_up_95;

                class tria_lo_95 {
                  public:

                    double value;

                     std::string source;
                     tria_lo_95() {
                        value = EMPTY_DOUBLE;

                    };
                } tria_lo_95;

                class te_95 {
                  public:

                    double value;

                     std::string source;
                     te_95() {
                        value = EMPTY_DOUBLE;

                    };
                } te_95;

                class ti_95 {
                  public:

                    double value;

                     std::string source;
                     ti_95() {
                        value = EMPTY_DOUBLE;

                    };
                } ti_95;

                class ne_95 {
                  public:

                    double value;

                     std::string source;
                     ne_95() {
                        value = EMPTY_DOUBLE;

                    };
                } ne_95;

                class ni_95 {
                  public:

                    double value;

                     std::string source;
                     ni_95() {
                        value = EMPTY_DOUBLE;

                    };
                } ni_95;

                class phi_95 {
                  public:

                    double value;

                     std::string source;
                     phi_95() {
                        value = EMPTY_DOUBLE;

                    };
                } phi_95;

                class rho_95 {
                  public:

                    double value;

                     std::string source;
                     rho_95() {
                        value = EMPTY_DOUBLE;

                    };
                } rho_95;

                class vtor_95 {
                  public:

                    double value;

                     std::string source;
                     vtor_95() {
                        value = EMPTY_DOUBLE;

                    };
                } vtor_95;
                ninety_five() {

                };
            } ninety_five;

            class pedestal {
              public:

                class te_ped {
                  public:

                    double value;

                     std::string source;
                     te_ped() {
                        value = EMPTY_DOUBLE;

                    };
                } te_ped;

                class ti_ped {
                  public:

                    double value;

                     std::string source;
                     ti_ped() {
                        value = EMPTY_DOUBLE;

                    };
                } ti_ped;

                class ne_ped {
                  public:

                    double value;

                     std::string source;
                     ne_ped() {
                        value = EMPTY_DOUBLE;

                    };
                } ne_ped;

                class ni_ped {
                  public:

                    double value;

                     std::string source;
                     ni_ped() {
                        value = EMPTY_DOUBLE;

                    };
                } ni_ped;

                class psi_ped {
                  public:

                    double value;

                     std::string source;
                     psi_ped() {
                        value = EMPTY_DOUBLE;

                    };
                } psi_ped;

                class phi_ped {
                  public:

                    double value;

                     std::string source;
                     phi_ped() {
                        value = EMPTY_DOUBLE;

                    };
                } phi_ped;

                class rho_ped {
                  public:

                    double value;

                     std::string source;
                     rho_ped() {
                        value = EMPTY_DOUBLE;

                    };
                } rho_ped;

                class q_ped {
                  public:

                    double value;

                     std::string source;
                     q_ped() {
                        value = EMPTY_DOUBLE;

                    };
                } q_ped;

                class pressure_ped {
                  public:

                    double value;

                     std::string source;
                     pressure_ped() {
                        value = EMPTY_DOUBLE;

                    };
                } pressure_ped;

                class vtor_ped {
                  public:

                    double value;

                     std::string source;
                     vtor_ped() {
                        value = EMPTY_DOUBLE;

                    };
                } vtor_ped;
                pedestal() {

                };
            } pedestal;

            class references {
              public:

                class plh {
                  public:

                    double value;

                     std::string source;
                     plh() {
                        value = EMPTY_DOUBLE;

                    };
                } plh;

                class picrh {
                  public:

                    double value;

                     std::string source;
                     picrh() {
                        value = EMPTY_DOUBLE;

                    };
                } picrh;

                class pecrh {
                  public:

                    double value;

                     std::string source;
                     pecrh() {
                        value = EMPTY_DOUBLE;

                    };
                } pecrh;

                class pnbi {
                  public:

                    double value;

                     std::string source;
                     pnbi() {
                        value = EMPTY_DOUBLE;

                    };
                } pnbi;

                class ip {
                  public:

                    double value;

                     std::string source;
                     ip() {
                        value = EMPTY_DOUBLE;

                    };
                } ip;

                class bvac_r {
                  public:

                    double value;

                     std::string source;
                     bvac_r() {
                        value = EMPTY_DOUBLE;

                    };
                } bvac_r;

                class zeffl {
                  public:

                    double value;

                     std::string source;
                     zeffl() {
                        value = EMPTY_DOUBLE;

                    };
                } zeffl;

                class nbar {
                  public:

                    double value;

                     std::string source;
                     nbar() {
                        value = EMPTY_DOUBLE;

                    };
                } nbar;

                class xecrh {
                  public:

                    double value;

                     std::string source;
                     xecrh() {
                        value = EMPTY_DOUBLE;

                    };
                } xecrh;

                class pol_flux {
                  public:

                    double value;

                     std::string source;
                     pol_flux() {
                        value = EMPTY_DOUBLE;

                    };
                } pol_flux;

                class enhancement {
                  public:

                    double value;

                     std::string source;
                     enhancement() {
                        value = EMPTY_DOUBLE;

                    };
                } enhancement;

                class isotopic {
                  public:

                    double value;

                     std::string source;
                     isotopic() {
                        value = EMPTY_DOUBLE;

                    };
                } isotopic;

                class nbi_td_ratio {
                  public:

                    double value;

                     std::string source;
                     nbi_td_ratio() {
                        value = EMPTY_DOUBLE;

                    };
                } nbi_td_ratio;

                class gas_puff {
                  public:

                    double value;

                     std::string source;
                     gas_puff() {
                        value = EMPTY_DOUBLE;

                    };
                } gas_puff;
                references() {

                };
            } references;

            class reactor {
              public:

                double pnetwork;
                 reactor() {
                    pnetwork = EMPTY_DOUBLE;

                };
            } reactor;

            class sol {
              public:

                class l_te_sol {
                  public:

                    double value;

                     std::string source;
                     l_te_sol() {
                        value = EMPTY_DOUBLE;

                    };
                } l_te_sol;

                class l_ti_sol {
                  public:

                    double value;

                     std::string source;
                     l_ti_sol() {
                        value = EMPTY_DOUBLE;

                    };
                } l_ti_sol;

                class l_ne_sol {
                  public:

                    double value;

                     std::string source;
                     l_ne_sol() {
                        value = EMPTY_DOUBLE;

                    };
                } l_ne_sol;

                class l_ni_sol {
                  public:

                    double value;

                     std::string source;
                     l_ni_sol() {
                        value = EMPTY_DOUBLE;

                    };
                } l_ni_sol;

                class l_qe_sol {
                  public:

                    double value;

                     std::string source;
                     l_qe_sol() {
                        value = EMPTY_DOUBLE;

                    };
                } l_qe_sol;

                class l_qi_sol {
                  public:

                    double value;

                     std::string source;
                     l_qi_sol() {
                        value = EMPTY_DOUBLE;

                    };
                } l_qi_sol;

                class p_rad_sol {
                  public:

                    double value;

                     std::string source;
                     p_rad_sol() {
                        value = EMPTY_DOUBLE;

                    };
                } p_rad_sol;

                class gas_puff {
                  public:

                    double value;

                     std::string source;
                     gas_puff() {
                        value = EMPTY_DOUBLE;

                    };
                } gas_puff;
                sol() {

                };
            } sol;

            class vol_ave {
              public:

                class te_ave {
                  public:

                    double value;

                     std::string source;
                     te_ave() {
                        value = EMPTY_DOUBLE;

                    };
                } te_ave;

                class ti_ave {
                  public:

                    double value;

                     std::string source;
                     ti_ave() {
                        value = EMPTY_DOUBLE;

                    };
                } ti_ave;

                class ne_ave {
                  public:

                    double value;

                     std::string source;
                     ne_ave() {
                        value = EMPTY_DOUBLE;

                    };
                } ne_ave;

                class dne_ave_dt {
                  public:

                    double value;

                     std::string source;
                     dne_ave_dt() {
                        value = EMPTY_DOUBLE;

                    };
                } dne_ave_dt;

                class ni_ave {
                  public:

                    double value;

                     std::string source;
                     ni_ave() {
                        value = EMPTY_DOUBLE;

                    };
                } ni_ave;

                class zeff_ave {
                  public:

                    double value;

                     std::string source;
                     zeff_ave() {
                        value = EMPTY_DOUBLE;

                    };
                } zeff_ave;

                class ti_o_te_ave {
                  public:

                    double value;

                     std::string source;
                     ti_o_te_ave() {
                        value = EMPTY_DOUBLE;

                    };
                } ti_o_te_ave;

                class meff_ave {
                  public:

                    double value;

                     std::string source;
                     meff_ave() {
                        value = EMPTY_DOUBLE;

                    };
                } meff_ave;

                class pellet_flux {
                  public:

                    double value;

                     std::string source;
                     pellet_flux() {
                        value = EMPTY_DOUBLE;

                    };
                } pellet_flux;

                Array < double, 1 > nions_ave;

                class omega_ave {
                  public:

                    double value;

                     std::string source;
                     omega_ave() {
                        value = EMPTY_DOUBLE;

                    };
                } omega_ave;
                vol_ave() {

                };
            } vol_ave;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            scenario & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class desc_tfcoils {
              public:

                int type;

                double phi;

                class circularcoil {
                  public:

                    class centre {
                      public:

                        double r;

                        double z;
                         centre() {
                            r = EMPTY_DOUBLE;
                            z = EMPTY_DOUBLE;

                        };
                    } centre;

                    double hlength;

                    double radialhwidth;
                    circularcoil() {
                        hlength = EMPTY_DOUBLE;
                        radialhwidth = EMPTY_DOUBLE;

                    };
                } circularcoil;

                class planecoil {
                  public:

                    class coordinates {
                      public:

                        Array < double, 1 > r;

                         Array < double, 1 > z;
                         coordinates() {

                        };
                    } coordinates;

                    Array < double, 1 > hlength;

                    Array < double, 1 > radialhwidth;
                    planecoil() {

                    };
                } planecoil;

                class structure {
                  public:

                    double jcable;

                    double tisotf;

                    double efcasing;

                    double escasing;

                    double sigjackettf;

                    double sigvaulttf;

                    double ktf;

                    double ritf;

                    double riitf;

                    double retf;
                     structure() {
                        jcable = EMPTY_DOUBLE;
                        tisotf = EMPTY_DOUBLE;
                        efcasing = EMPTY_DOUBLE;
                        escasing = EMPTY_DOUBLE;
                        sigjackettf = EMPTY_DOUBLE;
                        sigvaulttf = EMPTY_DOUBLE;
                        ktf = EMPTY_DOUBLE;
                        ritf = EMPTY_DOUBLE;
                        riitf = EMPTY_DOUBLE;
                        retf = EMPTY_DOUBLE;

                    };
                } structure;
                desc_tfcoils() {
                    type = EMPTY_INT;
                    phi = EMPTY_DOUBLE;

                };
            } desc_tfcoils;

            int nturns;

            int ncoils;

            class current {
              public:

                double value;

                double abserror;

                double relerror;
                 current() {
                    value = EMPTY_DOUBLE;
                    abserror = EMPTY_DOUBLE;
                    relerror = EMPTY_DOUBLE;

                };
            } current;

            class bvac_r {
              public:

                double value;

                double abserror;

                double relerror;
                 bvac_r() {
                    value = EMPTY_DOUBLE;
                    abserror = EMPTY_DOUBLE;
                    relerror = EMPTY_DOUBLE;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            toroidfield & operator()(int index) {
                return array(index);
            };
            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;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class setup {
              public:

                class position {
                  public:

                    Array < double, 1 > r;

                     Array < double, 1 > z;

                     Array < double, 1 > phi;
                     position() {

                    };
                } position;
                setup() {

                };
            } setup;

            class measure {
              public:

                class te {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     te() {

                    };
                } te;

                class ne {
                  public:

                    Array < double, 1 > value;

                     Array < double, 1 > abserror;

                     Array < double, 1 > relerror;
                     ne() {

                    };
                } ne;
                measure() {

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            tsdiag & operator()(int index) {
                return array(index);
            };
            tsdiag & operator[](int index) {
                return array(index);
            };
            int extent(int dim = 0) {
                return array.extent(dim);
            };
        };

        class turbulence:Cpo {
          private:
            int expIdx;
            bool connected;
          public:
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class composition {
              public:

                Array < double, 1 > amn;

                 Array < double, 1 > zn;

                 Array < double, 1 > zion;

                 Array < double, 1 > ie_mass;
                 composition() {

                };
            } composition;

            class coordsys {
              public:

                std::string grid_type;

                class turbgrid {
                  public:

                    Array < double, 1 > dim1;

                     Array < double, 1 > dim2;

                     Array < double, 1 > dim3;

                     Array < double, 1 > dim_v1;

                     Array < double, 1 > dim_v2;
                     turbgrid() {

                    };
                } turbgrid;

                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;

                class position {
                  public:

                    Array < double, 3 > r;

                     Array < double, 3 > z;

                     Array < double, 3 > phi;
                     position() {

                    };
                } position;
                coordsys() {

                };
            } coordsys;

            class var0d {
              public:

                std::string dtime_type;

                Array < double, 1 > dtime;

                 Array < double, 1 > en_exb;

                 Array < double, 1 > en_mag;

                 Array < double, 1 > en_el_th;

                 Array < double, 2 > en_ion_th;

                 Array < double, 1 > en_el_par;

                 Array < double, 2 > en_ion_par;

                 Array < double, 1 > en_tot;

                 Array < double, 1 > fl_el;

                 Array < double, 1 > fl_heatel;

                 Array < double, 2 > fl_ion;

                 Array < double, 2 > fl_heation;

                 Array < double, 1 > fl_magel;

                 Array < double, 1 > fl_magheatel;

                 Array < double, 2 > fl_magion;

                 Array < double, 2 > flmagheation;
                 var0d() {

                };
            } var0d;

            class var1d {
              public:

                Array < double, 1 > rho_tor_norm;

                 Array < double, 1 > phi;

                 Array < double, 1 > er;

                 Array < double, 1 > vor;

                 Array < double, 1 > apl;

                 Array < double, 1 > jpl;

                 Array < double, 1 > ne;

                 Array < double, 1 > te;

                 Array < double, 2 > ni;

                 Array < double, 2 > ti;

                 Array < double, 2 > ui;
                 var1d() {

                };
            } var1d;

            class var2d {
              public:

                Array < double, 1 > rho_tor_norm;

                 Array < double, 1 > theta;

                 Array < double, 2 > phi;

                 Array < double, 2 > apl;

                 Array < double, 2 > jpl;

                 Array < double, 2 > vor;

                 Array < double, 2 > ne;

                 Array < double, 2 > te;

                 Array < double, 3 > ni;

                 Array < double, 3 > ti;

                 Array < double, 3 > ui;
                 var2d() {

                };
            } var2d;

            class var3d {
              public:

                Array < double, 3 > phi;

                 Array < double, 3 > vor;

                 Array < double, 3 > jpl;

                 Array < double, 3 > ne;
                 var3d() {

                };
            } var3d;

            class var4d {
              public:

                Array < double, 4 > fe;

                 Array < double, 5 > fi;
                 var4d() {

                };
            } var4d;

            class var5d {
              public:

                Array < double, 5 > fe;

                 Array < double, 6 > fi;
                 var5d() {

                };
            } var5d;

            class spec1d {
              public:

                Array < double, 1 > kperp;

                 Array < double, 1 > phi;

                 Array < double, 1 > vor;

                 Array < double, 1 > b;

                 Array < double, 1 > jpl;

                 Array < double, 1 > ne;

                 Array < double, 1 > te;

                 Array < double, 2 > ti;

                 Array < double, 1 > fe;

                 Array < double, 1 > qe;

                 Array < double, 2 > qi;

                 Array < double, 1 > me;

                 Array < double, 2 > mi;
                 spec1d() {

                };
            } spec1d;

            class env1d {
              public:

                Array < double, 1 > theta;

                 Array < double, 1 > phi;

                 Array < double, 1 > vor;

                 Array < double, 1 > jpl;

                 Array < double, 1 > ne;

                 Array < double, 1 > he;

                 Array < double, 1 > te;

                 Array < double, 2 > ni;

                 Array < double, 2 > ti;

                 Array < double, 2 > ui;

                 Array < double, 1 > fe;

                 Array < double, 1 > qe;

                 Array < double, 2 > qi;

                 Array < double, 1 > me;

                 Array < double, 2 > mi;
                 env1d() {

                };
            } env1d;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } codeparam;

            double time;
            turbulence();
            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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            friend ostream & operator <<(ostream & os, const turbulence & obj);
        };
        class turbulenceArray:Cpo {
          private:
            int expIdx;
            bool connected;


          public:
             turbulenceArray() {
                connected = false;
            } void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            }
            Array < turbulence, 1 > array;

            int get();
            int put();
            int deleteAll();
            int deleteAll(int idx);
            int get(int idx);
            int put(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            turbulence & operator()(int index) {
                return array(index);
            };
            turbulence & operator[](int index) {
                return array(index);
            };
            int extent(int dim = 0) {
                return array.extent(dim);
            };
        };

        class vessel:Cpo {
          private:
            int expIdx;
            bool connected;
          public:

             class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class position {
              public:

                Array < double, 1 > r;

                 Array < double, 1 > z;
                 position() {

                };
            } position;
            vessel();
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            }
            int get();
            int get(int idx);
            int put();
            int put(int idx);
            void flush();
            void flush(int idx);
            void discard();
            void discard(int idx);
            friend ostream & operator <<(ostream & os, const vessel & obj);

        };

        class wall:Cpo {
          private:
            int expIdx;
            bool connected;
          public:
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class wall2d_mhd {
              public:

                class wall_id {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     wall_id() {
                        flag = EMPTY_INT;

                    };
                } wall_id;

                class res_wall {
                  public:

                    class walltype {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         walltype() {
                            flag = EMPTY_INT;

                        };
                    } walltype;

                    double delta;

                    double eta;

                    int npoloidal;

                    class position {
                      public:

                        Array < double, 1 > r;

                         Array < double, 1 > z;
                         position() {

                        };
                    } position;

                    class holes {
                      public:

                        int n_holes;

                        class coordinates {
                          public:

                            Array < double, 1 > theta;

                             Array < double, 1 > phi;
                             coordinates() {

                            };
                        } coordinates;

                        class width {
                          public:

                            Array < double, 1 > dtheta;

                             Array < double, 1 > phi;
                             width() {

                            };
                        } width;

                        Array < double, 1 > eta;
                        holes() {
                            n_holes = EMPTY_INT;

                        };
                    } holes;
                    res_wall() {
                        delta = EMPTY_DOUBLE;
                        eta = EMPTY_DOUBLE;
                        npoloidal = EMPTY_INT;

                    };
                };
                Array < class res_wall, 1 > res_wall;

                class ideal_wall {
                  public:

                    class walltype {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         walltype() {
                            flag = EMPTY_INT;

                        };
                    } walltype;

                    class position {
                      public:

                        Array < double, 1 > r;

                         Array < double, 1 > z;
                         position() {

                        };
                    } position;
                    ideal_wall() {

                    };
                } ideal_wall;
                wall2d_mhd() {

                };
            } wall2d_mhd;

            class wall2d {
              public:

                class wall_id {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     wall_id() {
                        flag = EMPTY_INT;

                    };
                } wall_id;

                class limiter {
                  public:

                    class limiter_unit {
                      public:

                        std::string name;

                        std::string closed;

                        class position {
                          public:

                            Array < double, 1 > r;

                             Array < double, 1 > z;
                             position() {

                            };
                        } position;

                        double eta;

                        double delta;

                        double permeability;
                        limiter_unit() {
                            eta = EMPTY_DOUBLE;
                            delta = EMPTY_DOUBLE;
                            permeability = EMPTY_DOUBLE;

                        };
                    };
                    Array < class limiter_unit, 1 > limiter_unit;
                    limiter() {

                    };
                } limiter;

                class vessel {
                  public:

                    class vessel_unit {
                      public:

                        class annular {
                          public:

                            std::string name;

                            class inside {
                              public:

                                Array < double, 1 > r;

                                 Array < double, 1 > z;
                                 inside() {

                                };
                            } inside;

                            class outside {
                              public:

                                Array < double, 1 > r;

                                 Array < double, 1 > z;
                                 outside() {

                                };
                            } outside;

                            double eta;

                            double permeability;
                            annular() {
                                eta = EMPTY_DOUBLE;
                                permeability = EMPTY_DOUBLE;

                            };
                        } annular;

                        class blocks {
                          public:

                            class blocks_unit {
                              public:

                                std::string name;

                                class position {
                                  public:

                                    Array < double, 1 > r;

                                     Array < double, 1 > z;
                                     position() {

                                    };
                                } position;

                                double eta;

                                double permeability;
                                blocks_unit() {
                                    eta = EMPTY_DOUBLE;
                                    permeability = EMPTY_DOUBLE;

                                };
                            };
                            Array < class blocks_unit, 1 > blocks_unit;
                            blocks() {

                            };
                        } blocks;
                        vessel_unit() {

                        };
                    };
                    Array < class vessel_unit, 1 > vessel_unit;
                    vessel() {

                    };
                } vessel;
                wall2d() {

                };
            };
            Array < class wall2d, 1 > wall2d;

            class wall3d {
              public:

                class wall_id {
                  public:

                    std::string id;

                    int flag;

                     std::string description;
                     wall_id() {
                        flag = EMPTY_INT;

                    };
                } wall_id;

                class grid {
                  public:

                    int uid;

                     std::string id;

                    class spaces {
                      public:

                        Array < int, 1 > geotype;

                         Array < std::string, 1 > geotypeid;

                         Array < int, 2 > coordtype;

                        class objects {
                          public:

                            Array < int, 2 > boundary;

                             Array < int, 3 > neighbour;

                             Array < double, 4 > geo;

                             Array < double, 2 > measure;
                             objects() {

                            };
                        };
                         Array < class objects, 1 > objects;

                         Array < int, 1 > xpoints;
                         spaces() {

                        };
                    };
                    Array < class spaces, 1 > spaces;

                    class subgrids {
                      public:

                        std::string id;

                        class list {
                          public:

                            Array < int, 1 > cls;

                            class indset {
                              public:

                                Array < int, 1 > range;

                                 Array < int, 1 > ind;
                                 indset() {

                                };
                            };
                             Array < class indset, 1 > indset;

                             Array < int, 2 > ind;
                             list() {

                            };
                        };
                        Array < class list, 1 > list;
                        subgrids() {

                        };
                    };
                    Array < class subgrids, 1 > subgrids;

                    class metric {
                      public:

                        class measure {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             measure() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class measure, 1 > measure;

                        class g11 {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             g11() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class g11, 1 > g11;

                        class g12 {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             g12() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class g12, 1 > g12;

                        class g13 {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             g13() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class g13, 1 > g13;

                        class g22 {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             g22() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class g22, 1 > g22;

                        class g23 {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             g23() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class g23, 1 > g23;

                        class g33 {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             g33() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class g33, 1 > g33;

                        class jacobian {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             jacobian() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class jacobian, 1 > jacobian;
                        metric() {

                        };
                    } metric;

                    class geo {
                      public:

                        int geotype;

                         std::string geotypeid;

                         Array < int, 1 > coordtype;

                        class geo_matrix {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             geo_matrix() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class geo_matrix, 1 > geo_matrix;

                        class measure {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             measure() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class measure, 1 > measure;
                        geo() {
                            geotype = EMPTY_INT;

                        };
                    };
                    Array < class geo, 1 > geo;

                    class bases {
                      public:

                        int griduid;

                         std::string label;

                        class comp {
                          public:

                            int griduid;

                            int subgrid;

                             Array < double, 1 > scalar;

                             Array < double, 2 > vector;

                             Array < double, 3 > matrix;
                             comp() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        };
                        Array < class comp, 1 > comp;

                        Array < int, 1 > align;

                        Array < std::string, 1 > alignid;

                        int basis;
                        bases() {
                            griduid = EMPTY_INT;
                            basis = EMPTY_INT;

                        };
                    };
                    Array < class bases, 1 > bases;
                    grid() {
                        uid = EMPTY_INT;

                    };
                } grid;
                wall3d() {

                };
            };
            Array < class wall3d, 1 > wall3d;

            class plasma {
              public:

                class flux {
                  public:

                    int griduid;

                    int subgrid;

                     Array < double, 1 > scalar;

                     Array < double, 2 > vector;

                     Array < double, 3 > matrix;
                     flux() {
                        griduid = EMPTY_INT;
                        subgrid = EMPTY_INT;

                    };
                };
                Array < class flux, 1 > flux;

                class b {
                  public:

                    std::string label;

                    class comp {
                      public:

                        int griduid;

                        int subgrid;

                         Array < double, 1 > scalar;

                         Array < double, 2 > vector;

                         Array < double, 3 > matrix;
                         comp() {
                            griduid = EMPTY_INT;
                            subgrid = EMPTY_INT;

                        };
                    };
                    Array < class comp, 1 > comp;

                    Array < int, 1 > align;

                    Array < std::string, 1 > alignid;
                    b() {

                    };
                } b;

                class energy {
                  public:

                    int griduid;

                    int subgrid;

                     Array < double, 1 > scalar;

                     Array < double, 2 > vector;

                     Array < double, 3 > matrix;
                     energy() {
                        griduid = EMPTY_INT;
                        subgrid = EMPTY_INT;

                    };
                };
                Array < class energy, 1 > energy;

                class species {
                  public:

                    std::string label;

                    double amn;

                    double zn;

                    double zmin;

                    double zmax;
                     species() {
                        amn = EMPTY_DOUBLE;
                        zn = EMPTY_DOUBLE;
                        zmin = EMPTY_DOUBLE;
                        zmax = EMPTY_DOUBLE;

                    };
                };
                Array < class species, 1 > species;
                plasma() {

                };
            } plasma;

            class surface {
              public:

                class ref_wall_typ {
                  public:

                    std::string label;

                    Array < double, 1 > thickness;

                     Array < double, 2 > stochiometry;

                     Array < double, 2 > dx;
                     ref_wall_typ() {

                    };
                };
                Array < class ref_wall_typ, 1 > ref_wall_typ;

                class wall_type {
                  public:

                    int griduid;

                    int subgrid;

                     Array < int, 1 > scalar;

                     Array < int, 2 > vector;

                     Array < int, 3 > matrix;
                     wall_type() {
                        griduid = EMPTY_INT;
                        subgrid = EMPTY_INT;

                    };
                } wall_type;

                class layers {
                  public:

                    Array < double, 2 > density;

                     Array < double, 2 > thickness;

                     Array < double, 2 > roughness;

                     Array < double, 3 > t;

                     Array < double, 3 > element_frac;

                     Array < double, 3 > chem_comp;
                     layers() {

                    };
                } layers;

                class h_inventory {
                  public:

                    Array < double, 5 > surf_trap_de;

                     Array < double, 5 > bulk_trap_de;

                     Array < double, 5 > bulk_D;

                     Array < double, 5 > surface_D;

                     Array < double, 5 > bulk_C_s;

                     Array < double, 5 > surface_C_s;

                     Array < double, 5 > bulk_C_t;

                     Array < double, 5 > surface_C_t;

                     Array < double, 5 > surf_recrate;
                     h_inventory() {

                    };
                } h_inventory;

                class elements {
                  public:

                    std::string label;

                    int zn;

                    double amn;

                    double density;
                     elements() {
                        zn = EMPTY_INT;
                        amn = EMPTY_DOUBLE;
                        density = EMPTY_DOUBLE;

                    };
                };
                Array < class elements, 1 > elements;

                class compounds {
                  public:

                    std::string label;

                    Array < double, 1 > stochiometry;

                    double density;
                     compounds() {
                        density = EMPTY_DOUBLE;

                    };
                };
                Array < class compounds, 1 > compounds;
                surface() {

                };
            } surface;

            double time;
            wall();
            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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            friend ostream & operator <<(ostream & os, const wall & obj);
        };
        class wallArray:Cpo {
          private:
            int expIdx;
            bool connected;


          public:
             wallArray() {
                connected = false;
            } void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            }
            Array < wall, 1 > array;

            int get();
            int put();
            int deleteAll();
            int deleteAll(int idx);
            int get(int idx);
            int put(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            wall & operator()(int index) {
                return array(index);
            };
            wall & operator[](int index) {
                return array(index);
            };
            int extent(int dim = 0) {
                return array.extent(dim);
            };
        };

        class waves:Cpo {
          private:
            int expIdx;
            bool connected;
          public:
            void setExpIdx(int expIdx) {
                this->expIdx = expIdx;
                connected = true;
            } class datainfo {
              public:

                std::string dataprovider;

                std::string putdate;

                std::string source;

                std::string comment;

                int cocos;

                int id;

                int isref;

                class whatref {
                  public:

                    std::string user;

                    std::string machine;

                    int shot;

                    int run;

                    int occurrence;
                     whatref() {
                        shot = EMPTY_INT;
                        run = EMPTY_INT;
                        occurrence = EMPTY_INT;

                    };
                } whatref;

                class putinfo {
                  public:

                    std::string putmethod;

                    std::string putaccess;

                    std::string putlocation;

                    std::string rights;
                    putinfo() {

                    };
                } putinfo;
                datainfo() {
                    cocos = EMPTY_INT;
                    id = EMPTY_INT;
                    isref = EMPTY_INT;

                };
            } datainfo;

            class coherentwave {
              public:

                class wave_id {
                  public:

                    class type {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         type() {
                            flag = EMPTY_INT;

                        };
                    } type;

                    std::string name;

                    int index;
                    wave_id() {
                        index = EMPTY_INT;

                    };
                } wave_id;

                class composition {
                  public:

                    Array < double, 1 > amn;

                     Array < double, 1 > zn;

                     Array < double, 1 > zion;

                     Array < int, 1 > imp_flag;

                     Array < std::string, 1 > label;
                     composition() {

                    };
                } composition;

                class compositions {
                  public:

                    class nuclei {
                      public:

                        double zn;

                        double amn;

                         std::string label;
                         nuclei() {
                            zn = EMPTY_DOUBLE;
                            amn = EMPTY_DOUBLE;

                        };
                    };
                    Array < class nuclei, 1 > nuclei;

                    class ions {
                      public:

                        int nucindex;

                        double zion;

                        int imp_flag;

                         std::string label;
                         ions() {
                            nucindex = EMPTY_INT;
                            zion = EMPTY_DOUBLE;
                            imp_flag = EMPTY_INT;

                        };
                    };
                    Array < class ions, 1 > ions;

                    class impurities {
                      public:

                        int nucindex;

                        int i_ion;

                        int nzimp;

                         Array < double, 1 > zmin;

                         Array < double, 1 > zmax;

                         Array < std::string, 1 > label;
                         impurities() {
                            nucindex = EMPTY_INT;
                            i_ion = EMPTY_INT;
                            nzimp = EMPTY_INT;

                        };
                    };
                    Array < class impurities, 1 > impurities;

                    class neutralscomp {
                      public:

                        class neutcomp {
                          public:

                            int nucindex;

                            int multiplicity;
                             neutcomp() {
                                nucindex = EMPTY_INT;
                                multiplicity = EMPTY_INT;

                            };
                        };
                        Array < class neutcomp, 1 > neutcomp;

                        class type {
                          public:

                            std::string id;

                            int flag;

                             std::string description;
                             type() {
                                flag = EMPTY_INT;

                            };
                        };
                        Array < class type, 1 > type;

                        std::string label;
                        neutralscomp() {

                        };
                    };
                    Array < class neutralscomp, 1 > neutralscomp;

                    class edgespecies {
                      public:

                        int nucindex;

                        double zmin;

                        double zmax;

                         std::string label;
                         edgespecies() {
                            nucindex = EMPTY_INT;
                            zmin = EMPTY_DOUBLE;
                            zmax = EMPTY_DOUBLE;

                        };
                    };
                    Array < class edgespecies, 1 > edgespecies;

                    class signature {
                      public:

                        std::string id;

                        int flag;

                         std::string description;
                         signature() {
                            flag = EMPTY_INT;

                        };
                    } signature;
                    compositions() {

                    };
                } compositions;

                class global_param {
                  public:

                    double frequency;

                     std::string name;

                     std::string type;

                     Array < int, 1 > ntor;

                     Array < int, 1 > f_assumption;

                    double power_tot;

                     Array < double, 1 > p_frac_ntor;

                     Array < double, 1 > pow_i;

                    double pow_e;

                     Array < double, 2 > pow_ntor_i;

                     Array < double, 1 > pow_ntor_e;

                    double cur_tor;

                     Array < double, 1 > cur_tor_ntor;

                    int code_type;

                    class toroid_field {
                      public:

                        double r0;

                        double b0;
                         toroid_field() {
                            r0 = EMPTY_DOUBLE;
                            b0 = EMPTY_DOUBLE;

                        };
                    } toroid_field;
                    global_param() {
                        frequency = EMPTY_DOUBLE;
                        power_tot = EMPTY_DOUBLE;
                        pow_e = EMPTY_DOUBLE;
                        cur_tor = EMPTY_DOUBLE;
                        code_type = EMPTY_INT;

                    };
                } global_param;

                class grid_1d {
                  public:

                    Array < double, 1 > rho_tor_norm;

                     Array < double, 1 > rho_tor;

                     Array < double, 1 > psi;
                     grid_1d() {

                    };
                } grid_1d;

                class grid_2d {
                  public:

                    int grid_type;

                     Array < double, 2 > rho_tor_norm;

                     Array < double, 2 > rho_tor;

                     Array < double, 2 > psi;

                     Array < double, 2 > theta;

                     Array < double, 2 > r;

                     Array < double, 2 > z;

                    class theta_info {
                      public:

                        int angl_type;

                         Array < double, 2 > th2th_pol;
                         theta_info() {
                            angl_type = EMPTY_INT;

                        };
                    } theta_info;
                    grid_2d() {
                        grid_type = EMPTY_INT;

                    };
                } grid_2d;

                class profiles_1d {
                  public:

                    Array < double, 1 > powd_tot;

                     Array < double, 1 > powd_e;

                     Array < double, 2 > powd_i;

                     Array < double, 2 > powd_ntor;

                     Array < double, 2 > powd_ntor_e;

                     Array < double, 3 > powd_ntor_i;

                     Array < double, 1 > curd_tor;

                     Array < double, 2 > curd_torntor;

                     Array < double, 1 > pow_tot;

                     Array < double, 1 > pow_e;

                     Array < double, 2 > pow_i;

                     Array < double, 3 > pow_ntor;

                     Array < double, 2 > pow_ntor_e;

                     Array < double, 3 > pow_ntor_i;

                     Array < double, 1 > curd_par;

                     Array < double, 2 > curd_parntor;

                     Array < double, 1 > cur_tor;

                     Array < double, 2 > cur_tor_ntor;
                     profiles_1d() {

                    };
                } profiles_1d;

                class profiles_2d {
                  public:

                    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, 5 > powd_iharm;
                     profiles_2d() {

                    };
                } profiles_2d;

                class beamtracing {
                  public:

                    int npoints;

                    double power;

                     Array < double, 1 > dnpar;

                     Array < double, 1 > length;

                    class position {
                      public:

                        Array < double, 1 > r;

                         Array < double, 1 > z;

                         Array < double, 1 > phi;

                         Array < double, 1 > psi;

                         Array < double, 1 > theta;
                         position() {

                        };
                    } position;

                    class wavevector {
                      public:

                        Array < double, 1 > kr;

                         Array < double, 1 > kz;

                         Array < double, 1 > kphi;

                         Array < double, 1 > npar;

                         Array < double, 1 > nperp;

                         Array < double, 1 > ntor;

                        int var_ntor;
                         wavevector() {
                            var_ntor = EMPTY_INT;

                        };
                    } wavevector;

                    class polarization {
                      public:

                        Array < double, 1 > epol_p_re;

                         Array < double, 1 > epol_p_im;

                         Array < double, 1 > epol_m_re;

                         Array < double, 1 > epol_m_im;

                         Array < double, 1 > epol_par_re;

                         Array < double, 1 > epol_par_im;
                         polarization() {

                        };
                    } polarization;

                    class powerflow {
                      public:

                        Array < double, 1 > phi_perp;

                         Array < double, 1 > phi_par;

                         Array < double, 1 > power_e;

                         Array < double, 2 > power_i;
                         powerflow() {

                        };
                    } powerflow;
                    beamtracing() {
                        npoints = EMPTY_INT;
                        power = EMPTY_DOUBLE;

                    };
                };
                Array < class beamtracing, 1 > beamtracing;

                class fullwave {
                  public:

                    class grid {
                      public:

                        int uid;

                         std::string id;

                        class spaces {
                          public:

                            Array < int, 1 > geotype;

                             Array < std::string, 1 > geotypeid;

                             Array < int, 2 > coordtype;

                            class objects {
                              public:

                                Array < int, 2 > boundary;

                                 Array < int, 3 > neighbour;

                                 Array < double, 4 > geo;

                                 Array < double, 2 > measure;
                                 objects() {

                                };
                            };
                             Array < class objects, 1 > objects;

                             Array < int, 1 > xpoints;
                             spaces() {

                            };
                        };
                        Array < class spaces, 1 > spaces;

                        class subgrids {
                          public:

                            std::string id;

                            class list {
                              public:

                                Array < int, 1 > cls;

                                class indset {
                                  public:

                                    Array < int, 1 > range;

                                     Array < int, 1 > ind;
                                     indset() {

                                    };
                                };
                                 Array < class indset, 1 > indset;

                                 Array < int, 2 > ind;
                                 list() {

                                };
                            };
                            Array < class list, 1 > list;
                            subgrids() {

                            };
                        };
                        Array < class subgrids, 1 > subgrids;

                        class metric {
                          public:

                            class measure {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 measure() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class measure, 1 > measure;

                            class g11 {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 g11() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class g11, 1 > g11;

                            class g12 {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 g12() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class g12, 1 > g12;

                            class g13 {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 g13() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class g13, 1 > g13;

                            class g22 {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 g22() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class g22, 1 > g22;

                            class g23 {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 g23() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class g23, 1 > g23;

                            class g33 {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 g33() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class g33, 1 > g33;

                            class jacobian {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 jacobian() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class jacobian, 1 > jacobian;
                            metric() {

                            };
                        } metric;

                        class geo {
                          public:

                            int geotype;

                             std::string geotypeid;

                             Array < int, 1 > coordtype;

                            class geo_matrix {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 geo_matrix() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class geo_matrix, 1 > geo_matrix;

                            class measure {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 measure() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class measure, 1 > measure;
                            geo() {
                                geotype = EMPTY_INT;

                            };
                        };
                        Array < class geo, 1 > geo;

                        class bases {
                          public:

                            int griduid;

                             std::string label;

                            class comp {
                              public:

                                int griduid;

                                int subgrid;

                                 Array < double, 1 > scalar;

                                 Array < double, 2 > vector;

                                 Array < double, 3 > matrix;
                                 comp() {
                                    griduid = EMPTY_INT;
                                    subgrid = EMPTY_INT;

                                };
                            };
                            Array < class comp, 1 > comp;

                            Array < int, 1 > align;

                            Array < std::string, 1 > alignid;

                            int basis;
                            bases() {
                                griduid = EMPTY_INT;
                                basis = EMPTY_INT;

                            };
                        };
                        Array < class bases, 1 > bases;
                        grid() {
                            uid = EMPTY_INT;

                        };
                    } grid;

                    class e_components {
                      public:

                        class e_plus {
                          public:

                            int griduid;

                            int subgrid;

                            class scalar {
                              public:

                                Array < double, 1 > re;

                                 Array < double, 1 > im;
                                 scalar() {

                                };
                            } scalar;

                            class vector {
                              public:

                                Array < double, 2 > re;

                                 Array < double, 2 > im;
                                 vector() {

                                };
                            } vector;

                            class matrix {
                              public:

                                Array < double, 3 > re;

                                 Array < double, 3 > im;
                                 matrix() {

                                };
                            } matrix;
                            e_plus() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        } e_plus;

                        class e_minus {
                          public:

                            int griduid;

                            int subgrid;

                            class scalar {
                              public:

                                Array < double, 1 > re;

                                 Array < double, 1 > im;
                                 scalar() {

                                };
                            } scalar;

                            class vector {
                              public:

                                Array < double, 2 > re;

                                 Array < double, 2 > im;
                                 vector() {

                                };
                            } vector;

                            class matrix {
                              public:

                                Array < double, 3 > re;

                                 Array < double, 3 > im;
                                 matrix() {

                                };
                            } matrix;
                            e_minus() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        } e_minus;

                        class e_para {
                          public:

                            int griduid;

                            int subgrid;

                            class scalar {
                              public:

                                Array < double, 1 > re;

                                 Array < double, 1 > im;
                                 scalar() {

                                };
                            } scalar;

                            class vector {
                              public:

                                Array < double, 2 > re;

                                 Array < double, 2 > im;
                                 vector() {

                                };
                            } vector;

                            class matrix {
                              public:

                                Array < double, 3 > re;

                                 Array < double, 3 > im;
                                 matrix() {

                                };
                            } matrix;
                            e_para() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        } e_para;

                        class e_norm {
                          public:

                            int griduid;

                            int subgrid;

                            class scalar {
                              public:

                                Array < double, 1 > re;

                                 Array < double, 1 > im;
                                 scalar() {

                                };
                            } scalar;

                            class vector {
                              public:

                                Array < double, 2 > re;

                                 Array < double, 2 > im;
                                 vector() {

                                };
                            } vector;

                            class matrix {
                              public:

                                Array < double, 3 > re;

                                 Array < double, 3 > im;
                                 matrix() {

                                };
                            } matrix;
                            e_norm() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        } e_norm;

                        class e_binorm {
                          public:

                            int griduid;

                            int subgrid;

                            class scalar {
                              public:

                                Array < double, 1 > re;

                                 Array < double, 1 > im;
                                 scalar() {

                                };
                            } scalar;

                            class vector {
                              public:

                                Array < double, 2 > re;

                                 Array < double, 2 > im;
                                 vector() {

                                };
                            } vector;

                            class matrix {
                              public:

                                Array < double, 3 > re;

                                 Array < double, 3 > im;
                                 matrix() {

                                };
                            } matrix;
                            e_binorm() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        } e_binorm;

                        class b_norm {
                          public:

                            int griduid;

                            int subgrid;

                            class scalar {
                              public:

                                Array < double, 1 > re;

                                 Array < double, 1 > im;
                                 scalar() {

                                };
                            } scalar;

                            class vector {
                              public:

                                Array < double, 2 > re;

                                 Array < double, 2 > im;
                                 vector() {

                                };
                            } vector;

                            class matrix {
                              public:

                                Array < double, 3 > re;

                                 Array < double, 3 > im;
                                 matrix() {

                                };
                            } matrix;
                            b_norm() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        } b_norm;

                        class b_binorm {
                          public:

                            int griduid;

                            int subgrid;

                            class scalar {
                              public:

                                Array < double, 1 > re;

                                 Array < double, 1 > im;
                                 scalar() {

                                };
                            } scalar;

                            class vector {
                              public:

                                Array < double, 2 > re;

                                 Array < double, 2 > im;
                                 vector() {

                                };
                            } vector;

                            class matrix {
                              public:

                                Array < double, 3 > re;

                                 Array < double, 3 > im;
                                 matrix() {

                                };
                            } matrix;
                            b_binorm() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        } b_binorm;

                        class b_para {
                          public:

                            int griduid;

                            int subgrid;

                            class scalar {
                              public:

                                Array < double, 1 > re;

                                 Array < double, 1 > im;
                                 scalar() {

                                };
                            } scalar;

                            class vector {
                              public:

                                Array < double, 2 > re;

                                 Array < double, 2 > im;
                                 vector() {

                                };
                            } vector;

                            class matrix {
                              public:

                                Array < double, 3 > re;

                                 Array < double, 3 > im;
                                 matrix() {

                                };
                            } matrix;
                            b_para() {
                                griduid = EMPTY_INT;
                                subgrid = EMPTY_INT;

                            };
                        } b_para;
                        e_components() {

                        };
                    } e_components;

                    class pol_decomp {
                      public:

                        Array < int, 1 > mpol;

                         Array < double, 3 > e_plus;

                         Array < double, 3 > e_plus_ph;

                         Array < double, 3 > e_minus;

                         Array < double, 3 > e_minus_ph;

                         Array < double, 3 > e_norm;

                         Array < double, 3 > e_norm_ph;

                         Array < double, 3 > e_binorm;

                         Array < double, 3 > e_binorm_ph;

                         Array < double, 3 > e_para;

                         Array < double, 3 > e_para_ph;

                         Array < double, 3 > b_norm;

                         Array < double, 3 > b_norm_ph;

                         Array < double, 3 > b_binorm;

                         Array < double, 3 > b_binorm_ph;

                         Array < double, 3 > b_para;

                         Array < double, 3 > b_para_ph;
                         pol_decomp() {

                        };
                    } pol_decomp;

                    class local {
                      public:

                        Array < double, 3 > e_plus;

                         Array < double, 3 > e_plus_ph;

                         Array < double, 3 > e_minus;

                         Array < double, 3 > e_minus_ph;

                         Array < int, 3 > e_norm;

                         Array < double, 3 > enorm_ph;

                         Array < double, 3 > e_binorm;

                         Array < double, 3 > e_binorm_ph;

                         Array < double, 3 > e_para;

                         Array < double, 3 > e_para_ph;

                         Array < double, 3 > b_norm;

                         Array < double, 3 > b_norm_ph;

                         Array < double, 3 > b_binorm;

                         Array < double, 3 > b_binorm_ph;

                         Array < double, 3 > b_para;

                         Array < double, 3 > b_para_ph;
                         local() {

                        };
                    } local;
                    fullwave() {

                    };
                } fullwave;

                class codeparam {
                  public:

                    std::string codename;

                    std::string codeversion;

                    std::string parameters;

                    std::string output_diag;

                    int output_flag;
                     codeparam() {
                        output_flag = EMPTY_INT;

                    };
                } codeparam;
                coherentwave() {

                };
            };
            Array < class coherentwave, 1 > coherentwave;

            class codeparam {
              public:

                std::string codename;

                std::string codeversion;

                std::string parameters;

                std::string output_diag;

                int output_flag;
                 codeparam() {
                    output_flag = EMPTY_INT;

                };
            } 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 deleteAll();
            int deleteAll(int idx);
            int remove();
            int remove(int idx);
            int putNonTimed();
            int putNonTimed(int idx);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            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);
            void discardCache();
            void discardCache(int idx);
            void flushCache();
            void flushCache(int idx);
            waves & operator()(int index) {
                return array(index);
            };
            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;
        compositionc _compositionc;
        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;
        efcc _efcc;
        efccArray _efccArray;
        equilibrium _equilibrium;
        equilibriumArray _equilibriumArray;
        fusiondiag _fusiondiag;
        fusiondiagArray _fusiondiagArray;
        halphadiag _halphadiag;
        halphadiagArray _halphadiagArray;
        interfdiag _interfdiag;
        interfdiagArray _interfdiagArray;
        ironmodel _ironmodel;
        ironmodelArray _ironmodelArray;
        langmuirdiag _langmuirdiag;
        langmuirdiagArray _langmuirdiagArray;
        launchs _launchs;
        launchsArray _launchsArray;
        limiter _limiter;
        lithiumdiag _lithiumdiag;
        lithiumdiagArray _lithiumdiagArray;
        mhd _mhd;
        mhdArray _mhdArray;
        magdiag _magdiag;
        magdiagArray _magdiagArray;
        msediag _msediag;
        msediagArray _msediagArray;
        nbi _nbi;
        nbiArray _nbiArray;
        neoclassic _neoclassic;
        neoclassicArray _neoclassicArray;
        orbit _orbit;
        orbitArray _orbitArray;
        pellets _pellets;
        pelletsArray _pelletsArray;
        pfsystems _pfsystems;
        pfsystemsArray _pfsystemsArray;
        polardiag _polardiag;
        polardiagArray _polardiagArray;
        reference _reference;
        referenceArray _referenceArray;
        rfadiag _rfadiag;
        rfadiagArray _rfadiagArray;
        sawteeth _sawteeth;
        sawteethArray _sawteethArray;
        scenario _scenario;
        scenarioArray _scenarioArray;
        toroidfield _toroidfield;
        toroidfieldArray _toroidfieldArray;
        tsdiag _tsdiag;
        tsdiagArray _tsdiagArray;
        turbulence _turbulence;
        turbulenceArray _turbulenceArray;
        vessel _vessel;
        wall _wall;
        wallArray _wallArray;
        waves _waves;
        wavesArray _wavesArray;


    };
}

#endif