tutorials/02_variables_IO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 02 - Variables and HDF5 IO\n",
    "\n",
    "ReMKiT1D values of interest during simulations are almost always stored in `Variables`. This tutorial covers the following:\n",
    "\n",
    "1. Basic `Variable` construction\n",
    "2. Variable properties\n",
    "3. Variable class features - unit conversion, dimensions, xarray conversion, etc.\n",
    "4. Nodes and expression trees for derived variables\n",
    "5. Variable container\n",
    "6. Saving and loading ReMKiT1D hdf5 files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from RMK_support import Variable,varAndDual,node,varFromNode,VariableContainer,Grid,loadVarContFromHDF5,loadVariableFromHDF5,writeRMKHDF5,loadFromHDF5\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to construct variables, we require a grid object. We reuse the grid we built in the first tutorial. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid = Grid(xGrid = 0.1 * np.ones(16), \n",
    "            interpretXGridAsWidths = True, \n",
    "            vGrid = 0.1 * np.ones(8),\n",
    "            interpretVGridAsWidths = True,\n",
    "            lMax = 3,\n",
    "            )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Variable` constructor has many keyword argument options, only some of which will be explored here. The user is encouraged to explore other tutorials and examples, as well as the documentation to see how other options are used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a:\n",
      "['x']\n",
      "aUnits\n",
      "[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15.]\n"
     ]
    }
   ],
   "source": [
    "a = Variable(\"a\", # Name of the variable\n",
    "             grid, # Grid on which the variable lives\n",
    "             data = np.linspace(0,15,16), # Spatial grid vector - values of the variable\n",
    "                                          # - by default variables live on the spatial grid\n",
    "                                          # i.e. they are considered fluid\n",
    "             units = \"aUnits\", # Optional name of the variable units\n",
    "             unitSI = \"aSI\", # Optional name of the SI units corresponding to the variable\n",
    "             normSI = 10.0, # normalisation constant - i.e. aUnits/aSI\n",
    "             )\n",
    "\n",
    "print(a.name+\":\")\n",
    "print(a.dims) # Variable dimensions\n",
    "print(a.units) \n",
    "print(a.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we specify normSI we can convert between the units"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aSI\n",
      "[  0.  10.  20.  30.  40.  50.  60.  70.  80.  90. 100. 110. 120. 130.\n",
      " 140. 150.]\n",
      "And back:\n",
      "aUnits\n",
      "[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15.]\n"
     ]
    }
   ],
   "source": [
    "a.switchUnits()\n",
    "print(a.units) \n",
    "print(a.data)\n",
    "\n",
    "print(\"And back:\")\n",
    "a.switchUnits()\n",
    "print(a.units) \n",
    "print(a.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can interrogate the variable about its properties directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(a.isFluid) # The variable lives only on the x grid\n",
    "print(a.isDerived) # The variable is derived as opposed to implicit\n",
    "print(a.isScalar) # The variable is a scalar - 0D (always derived)\n",
    "print(a.isDistribution) # The variable lives on x,h,v\n",
    "print(a.isSingleHarmonic) # The variable lives on x,v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to automatically generate a variable and its dual at construction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,a_dual = varAndDual(\"a\",grid,\n",
    "             data = np.linspace(0,15,16), \n",
    "             units = \"aUnits\", \n",
    "             unitSI = \"aSI\", \n",
    "             normSI = 10.0, \n",
    "             ); # The warning here is just to make sure we are doing things on purpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "a_dual\n",
      "True\n",
      "gridToDual\n",
      "a_dual\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "print(a.name)\n",
    "print(a_dual.name)\n",
    "\n",
    "print(a_dual.isDerived) # The dual variable is derived from the regular grid variable\n",
    "print(a_dual.derivation.name) # The derivation name (more on this in next tutorial)\n",
    "\n",
    "print(a.dual.name) # Each variable is aware of its dual\n",
    "print(a_dual.dual.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also treat the variable on the dual grid as the primary variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "b_dual,b = varAndDual(\"b\",grid,primaryOnDualGrid=True) # Note the ordering:\n",
    "                                                       # the dual variable is returned first\n",
    "\n",
    "print(b_dual.isDerived)\n",
    "print(b.isDerived)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Derivations will be covered in the next tutorial, but a particular class of derived variable is easy enough to construct without the knowledge of derivations to warrant examining here. These are derived variables based on node derivations, i.e. converting Python expressions into Fortran-parsable form. \n",
    "\n",
    "Any variable can be wrapped into a `Node` object, which can then be used in Python expressions, producing new `Nodes`. Finally, a `Node` can be converted into a derived variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'RMK_support.derivations.NodeDerivation'>\n",
      "['a', 'b']\n",
      "\\text{c}= \\text{a}+2\\left(\\text{b}\\right)^{2}\n"
     ]
    }
   ],
   "source": [
    "cNode = node(a) + 2*node(b)**2 # This is a new node representing a + 2*b**2 \n",
    "\n",
    "c = varFromNode(\"c\",grid,cNode) # Converting a node into a variable\n",
    "\n",
    "print(type(c.derivation)) # Node derivation\n",
    "print(c.derivationArgs) # c depends on a and b \n",
    "\n",
    "print(c.latex()) # More on LaTeX representation in a later tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also manually create dual variable from an existing variable by using `makeDual`.\n",
    "\n",
    "This will also associate the new variable as the dual of the old."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c_dual\n"
     ]
    }
   ],
   "source": [
    "c_dual = c.makeDual(\"c_dual\")\n",
    "\n",
    "print(c.dual.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or, if we do not wish to assign the dual variable to some object, we can associate a dual with `withDual`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a2_dual\n"
     ]
    }
   ],
   "source": [
    "a2 = Variable(\"a2\",grid).withDual()\n",
    "\n",
    "print(a2.dual.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A note about variables on the dual grid in ReMKiT1D\n",
    "\n",
    "These variable live on the right cell faces, and only inner cell faces usually house evolved quantities in ReMKiT1D (except for periodic grids). However, since both variables on regular and the dual grid are stored in the same objects, the lengths of the data arrays are the same. This leads to the right-most cell face entry for dual grid variables to generally be unused, and set to 0 to avoid unintended behaviour. For the treatment of boundary conditions the reader is directed to the examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable Container\n",
    "\n",
    "While useful on their own, variables need to be stored in various containers in order to be used fully by both ReMKiT1D and the Python interface. The main container is the `VariableContainer`, which we construct and explore here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aUnits\n"
     ]
    }
   ],
   "source": [
    "vc = VariableContainer(grid) # An empty variable container\n",
    "\n",
    "# We can add multiple variables to the container (note that by default the VariableContainer adds the duals of any added variables)\n",
    "\n",
    "vc.add(a,b)\n",
    "\n",
    "# Variable containers provide accessors that require knowing the variable name\n",
    "\n",
    "print(vc[\"a\"].units) # This will correctly index variable a and retrieve its units\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c2\n",
      "['a', 'b']\n",
      "c3\n",
      "['a', 'b']\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "# Variables can also be renamed when adding them\n",
    "\n",
    "vc.add(c.rename(\"c2\")) \n",
    "\n",
    "c2 = vc[\"c2\"] # This will retrieve the variable that we just added, which is c, but renamed\n",
    "print(c2.name) # Check that it is indeed renamed\n",
    "print(c2.derivationArgs)\n",
    "\n",
    "# We can achieve the same effect of renaming and addition to the container like this\n",
    "\n",
    "vc[\"c3\"] = c \n",
    "print(vc[\"c3\"].name) # Check that it is indeed renamed\n",
    "print(vc[\"c3\"].derivationArgs)\n",
    "\n",
    "# Note that this does not change the original variable\n",
    "\n",
    "print(c.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The coordinates of the container include both the regular and staggered grid, and can also include time (mostly used when loading multiple data files)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'x': array([0.05, 0.15, 0.25, 0.35, 0.45, 0.55, 0.65, 0.75, 0.85, 0.95, 1.05,\n",
      "       1.15, 1.25, 1.35, 1.45, 1.55]), 'x_dual': array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. , 1.1, 1.2, 1.3,\n",
      "       1.4, 1.5, 1.6]), 'h': array([0, 1, 2, 3]), 'v': array([0.05, 0.15, 0.25, 0.35, 0.45, 0.55, 0.65, 0.75])}\n"
     ]
    }
   ],
   "source": [
    "print(vc.coords)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both individual variables and containers can be converted into xarray `DataArray`/`Dataset` objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray (x: 16)>\n",
      "array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n",
      "       13., 14., 15.])\n",
      "Dimensions without coordinates: x\n",
      "Attributes:\n",
      "    isDerived:         False\n",
      "    isDistribution:    False\n",
      "    units:             aUnits\n",
      "    isStationary:      False\n",
      "    isScalar:          False\n",
      "    isOnDualGrid:      False\n",
      "    priority:          0\n",
      "    derivationRule:    none\n",
      "    isSingleHarmonic:  False\n",
      "    normSI:            10.0\n",
      "    unitSI:            aSI\n"
     ]
    }
   ],
   "source": [
    "print(a.dataArr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.Dataset>\n",
      "Dimensions:  (x: 16, x_dual: 16, h: 4, v: 8, dim_0: 1)\n",
      "Coordinates:\n",
      "  * x        (x) float64 0.05 0.15 0.25 0.35 0.45 ... 1.15 1.25 1.35 1.45 1.55\n",
      "  * x_dual   (x_dual) float64 0.1 0.2 0.3 0.4 0.5 0.6 ... 1.2 1.3 1.4 1.5 1.6\n",
      "  * h        (h) int64 0 1 2 3\n",
      "  * v        (v) float64 0.05 0.15 0.25 0.35 0.45 0.55 0.65 0.75\n",
      "Dimensions without coordinates: dim_0\n",
      "Data variables:\n",
      "    time     (dim_0) float64 0.0\n",
      "    a        (x) float64 0.0 1.0 2.0 3.0 4.0 5.0 ... 11.0 12.0 13.0 14.0 15.0\n",
      "    a_dual   (x_dual) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
      "    b        (x) float64 0.0 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0\n",
      "    b_dual   (x_dual) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
      "    c2       (x) float64 0.0 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0\n",
      "    c2_dual  (x_dual) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
      "    c3       (x) float64 0.0 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0\n",
      "    c3_dual  (x_dual) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n"
     ]
    }
   ],
   "source": [
    "print(vc.dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that a_dual was initialised with the same values as a. For some derived variables we can evaluate them using the dataset. This depends on whether the derivation has a Python evaluation method defined. Interpolation does:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.Dataset>\n",
      "Dimensions:  (x: 16, x_dual: 16, h: 4, v: 8, dim_0: 1)\n",
      "Coordinates:\n",
      "  * x        (x) float64 0.05 0.15 0.25 0.35 0.45 ... 1.15 1.25 1.35 1.45 1.55\n",
      "  * x_dual   (x_dual) float64 0.1 0.2 0.3 0.4 0.5 0.6 ... 1.2 1.3 1.4 1.5 1.6\n",
      "  * h        (h) int64 0 1 2 3\n",
      "  * v        (v) float64 0.05 0.15 0.25 0.35 0.45 0.55 0.65 0.75\n",
      "Dimensions without coordinates: dim_0\n",
      "Data variables:\n",
      "    time     (dim_0) float64 0.0\n",
      "    a        (x) float64 0.0 1.0 2.0 3.0 4.0 5.0 ... 11.0 12.0 13.0 14.0 15.0\n",
      "    a_dual   (x_dual) float64 0.5 1.5 2.5 3.5 4.5 ... 11.5 12.5 13.5 14.5 15.5\n",
      "    b        (x) float64 0.0 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0\n",
      "    b_dual   (x_dual) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
      "    c2       (x) float64 0.0 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0\n",
      "    c2_dual  (x_dual) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
      "    c3       (x) float64 0.0 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0\n",
      "    c3_dual  (x_dual) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n"
     ]
    }
   ],
   "source": [
    "a_dual.evaluate(vc.dataset)\n",
    "\n",
    "#A following call to vc.dataset will now have the interpolated value of a_dual - showing that adding variables does not copy them!\n",
    "print(vc.dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The time variable is automatically added to all variable containers, and can become its own coordinate (see examples when loading simulation results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(vc[\"time\"].isScalar)\n",
    "print(vc[\"time\"].isDerived)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### HDF5 IO\n",
    "\n",
    "We can write the variable container defined above to a ReMKiT1D-readable HDF5 file - useful when producing custom initial conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "writeRMKHDF5(vc,\"test.h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then load either individual variables from the h5 file, or the entire variable container if we have it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray (x: 16)>\n",
      "array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n",
      "       13., 14., 15.])\n",
      "Dimensions without coordinates: x\n",
      "Attributes:\n",
      "    isDerived:         False\n",
      "    isDistribution:    False\n",
      "    units:             aUnits\n",
      "    isStationary:      False\n",
      "    isScalar:          False\n",
      "    isOnDualGrid:      False\n",
      "    priority:          0\n",
      "    derivationRule:    none\n",
      "    isSingleHarmonic:  False\n",
      "    normSI:            10.0\n",
      "    unitSI:            aSI\n"
     ]
    }
   ],
   "source": [
    "loaded_a = loadVariableFromHDF5(a,[\"test.h5\"]) # We need a list of files to load - allows for time series\n",
    "\n",
    "print(loaded_a.dataArr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.Dataset>\n",
      "Dimensions:  (x: 16, x_dual: 16, h: 4, v: 8, t: 1, dim_0: 1)\n",
      "Coordinates:\n",
      "  * x        (x) float64 0.05 0.15 0.25 0.35 0.45 ... 1.15 1.25 1.35 1.45 1.55\n",
      "  * x_dual   (x_dual) float64 0.1 0.2 0.3 0.4 0.5 0.6 ... 1.2 1.3 1.4 1.5 1.6\n",
      "  * h        (h) int64 0 1 2 3\n",
      "  * v        (v) float64 0.05 0.15 0.25 0.35 0.45 0.55 0.65 0.75\n",
      "  * t        (t) float64 0.0\n",
      "Dimensions without coordinates: dim_0\n",
      "Data variables:\n",
      "    time     (dim_0) float64 0.0\n",
      "    a        (x) float64 0.0 1.0 2.0 3.0 4.0 5.0 ... 11.0 12.0 13.0 14.0 15.0\n",
      "    a_dual   (x_dual) float64 0.5 1.5 2.5 3.5 4.5 ... 11.5 12.5 13.5 14.5 15.5\n",
      "    b        (x) float64 0.0 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0\n",
      "    b_dual   (x_dual) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
      "    c2       (x) float64 0.0 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0\n",
      "    c2_dual  (x_dual) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
      "    c3       (x) float64 0.0 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0 0.0\n",
      "    c3_dual  (x_dual) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/stefan/.local/lib/python3.8/site-packages/RMK_support/variable_container.py:807: UserWarning: Variable time already in VariableContainer. Overwriting.\n",
      "  warnings.warn(\n",
      "/home/stefan/.local/lib/python3.8/site-packages/RMK_support/variable_container.py:807: UserWarning: Variable a_dual already in VariableContainer. Overwriting.\n",
      "  warnings.warn(\n",
      "/home/stefan/.local/lib/python3.8/site-packages/RMK_support/variable_container.py:818: UserWarning: Variable a already in VariableContainer. Overwriting.\n",
      "  warnings.warn(\n",
      "/home/stefan/.local/lib/python3.8/site-packages/RMK_support/variable_container.py:807: UserWarning: Variable b_dual already in VariableContainer. Overwriting.\n",
      "  warnings.warn(\n",
      "/home/stefan/.local/lib/python3.8/site-packages/RMK_support/variable_container.py:818: UserWarning: Variable b already in VariableContainer. Overwriting.\n",
      "  warnings.warn(\n",
      "/home/stefan/.local/lib/python3.8/site-packages/RMK_support/variable_container.py:807: UserWarning: Variable c2_dual already in VariableContainer. Overwriting.\n",
      "  warnings.warn(\n",
      "/home/stefan/.local/lib/python3.8/site-packages/RMK_support/variable_container.py:818: UserWarning: Variable c2 already in VariableContainer. Overwriting.\n",
      "  warnings.warn(\n",
      "/home/stefan/.local/lib/python3.8/site-packages/RMK_support/variable_container.py:807: UserWarning: Variable c3_dual already in VariableContainer. Overwriting.\n",
      "  warnings.warn(\n",
      "/home/stefan/.local/lib/python3.8/site-packages/RMK_support/variable_container.py:818: UserWarning: Variable c3 already in VariableContainer. Overwriting.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "loaded_vc = loadVarContFromHDF5(*tuple(vc.variables), # *args should be a tuple of variables\n",
    "                                                      # this way we load all variables in the container \n",
    "                                filepaths=[\"test.h5\"]\n",
    "                                )\n",
    "print(loaded_vc.dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also load only using variable names, and the code will try its best to infer the properties of the variables (will lose a lot of information, but should keep dimensionality info)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.Dataset>\n",
      "Dimensions:  (x: 16, x_dual: 16, h: 4, v: 8, t: 1, dim_0: 1)\n",
      "Coordinates:\n",
      "  * x        (x) float64 0.05 0.15 0.25 0.35 0.45 ... 1.15 1.25 1.35 1.45 1.55\n",
      "  * x_dual   (x_dual) float64 0.1 0.2 0.3 0.4 0.5 0.6 ... 1.2 1.3 1.4 1.5 1.6\n",
      "  * h        (h) int64 0 1 2 3\n",
      "  * v        (v) float64 0.05 0.15 0.25 0.35 0.45 0.55 0.65 0.75\n",
      "  * t        (t) float64 0.0\n",
      "Dimensions without coordinates: dim_0\n",
      "Data variables:\n",
      "    time     (dim_0) float64 0.0\n",
      "    a        (x) float64 0.0 1.0 2.0 3.0 4.0 5.0 ... 11.0 12.0 13.0 14.0 15.0\n",
      "    a_dual   (x) float64 0.5 1.5 2.5 3.5 4.5 5.5 ... 11.5 12.5 13.5 14.5 15.5\n"
     ]
    }
   ],
   "source": [
    "loaded_vc_2 = loadFromHDF5(grid,[\"a\",\"a_dual\"],filepaths=[\"test.h5\"])\n",
    "\n",
    "print(loaded_vc_2.dataset)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(loaded_vc_2[\"a_dual\"].isDerived) # Does not know that a_dual is derived \n",
    "\n",
    "print(loaded_vc[\"a_dual\"].isDerived) # Correct because it was loaded using the Variable objects"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}