Repository: SNEWS2/snewpy

Issue:
Create a `NeutrinoFlux` class as a container for neutrino signal, produced by a supernova model
This is a discussion for a feature if we agree on #213.

## What I want
A `NeutrinoFlux` class, returned by `SupernovaModel.get_initial_flux` method.

An object which contains all the information about the neutrino signal from supernova model.
This information should be sufficient to 
* _Integrate the flux over time and/or energy_ - so it should have `T` and `E` points where it was calculated 
* _Apply an arbitrary neutrino mixing_ - so it needs to contain flux for all neutrino flavors

## What I suggest
1. I suggest using the `astropy.Quantity` classes to keep track of all the dimensions.
2. I suggest to keep the flux for all flavors in a single array with dimensions `(N_flavors,N_times,N_energies)` - this will make it easy to apply any transformation matrix, by just using matrix multiplication

So, something like this (pseudocode):

```python
class NeutrinoFlux:
    def __init__(self, data: Quantity[1/s/MeV], axes: Dict[str, Quantity]):
                 """ axes could be a dict{
                     'Flavors': list[Flavor], 
                     'E': Quantity[MeV],
                     'T': Quantity[s] }
                 """
       self.data = data
       self.axes = axes
        
    def apply(self, flavor_xform: FlavorTransformation) -> NeutrinoFlux:
        #apply the given mixing an return the transformed flux
        flux_transformed = flavor_xform @ self.flux #we can use matrix multiplication
        return NeutrinoFlux(flux_transformed, self.axes) 

```

## Benefits
1. Apply mixing having only `FlavorTransformation` and `NeutrinoFlux` classes (not coupled to `SupernovaModel`) - which is logical, because mixing acts on the neutrino signal rather than the supernova itself. 
2. Pass the `NeutrinoFlux` to the SNOwGLoBES/SimpleRate calculation directly. 

So instead of (or as alternative to) calling (pseudocode)
```python
files = generate_time_series(model, transformation, distance, E, t, ...)
results = simulate(files, detector, ...)
```
one could do
```python
flux = model.get_initial_flux(distance, E, t)
flux = flux.apply(transformation) 
results = rate_calculator.run(flux, detector, ...)
```
and have access to all the intermediate results IN MEMORY without reading additional files

Discussion:

Patch:
diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
index 1501345..1454480 100644
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -31,12 +31,10 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install pytest
-          if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
       - name: Install SNEWPY
         run: |
-          python setup.py install --user
+          pip install ".[dev]"
       - name: Run Integration Tests
         run: |
           python -m unittest python/snewpy/test/simplerate_integrationtest.py
-          pytest -m 'snowglobes'
\ No newline at end of file
+          pytest -m 'snowglobes'
diff --git a/.gitignore b/.gitignore
index b96fdfb..05a984d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,4 +18,7 @@ fluence_Bollig_2016_s*
 
 # editor-specific
 .ipynb_checkpoints/
-.vscode/
\ No newline at end of file
+.vscode/
+
+#hypothesis package cache
+.hypothesis/
diff --git a/doc/nb/FluxContainer_demo.ipynb b/doc/nb/FluxContainer_demo.ipynb
new file mode 100644
index 0000000..c6da9b5
--- /dev/null
+++ b/doc/nb/FluxContainer_demo.ipynb
@@ -0,0 +1,1098 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "97774e5c-1aa9-4837-a0e0-d7779899e42f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from astropy import units as u\n",
+    "from snewpy.models import presn, ccsn\n",
+    "from snewpy.neutrino import Flavor\n",
+    "\n",
+    "import pylab as plt\n",
+    "from contextlib import contextmanager\n",
+    "plt.style.use('seaborn-talk')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "60602bc2-e42e-4a6b-851b-e3ef18ecee47",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@contextmanager\n",
+    "def raises(exception):\n",
+    "    \"A small utility to catch and show the exceptions\"\n",
+    "    try:\n",
+    "        yield\n",
+    "    except exception as e:\n",
+    "        print(f'{exception.__name__}: {e}')\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58cc1f01-6cb6-483f-9021-deaa305a02e5",
+   "metadata": {},
+   "source": [
+    "# Usage of flux.Container interface"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2534469c-9e26-429f-97d1-440b1ba3379c",
+   "metadata": {},
+   "source": [
+    "## 1. Initialize model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "f3f749f5-b82f-42c1-b1cf-8606005c5e76",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "model = ccsn.Bollig_2016(progenitor_mass=27<<u.Msun)\n",
+    "\n",
+    "times    = model.time #np.linspace(0,2,1500)<<u.second;\n",
+    "energies = np.linspace(0,50,501)<<u.MeV"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1d3ac52f-9766-48de-8aeb-fefb0d51a338",
+   "metadata": {},
+   "source": [
+    "## 2. Calculate flux"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "54e252f0-969b-4b40-a9c9-db60df9dc46f",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ash/work/snews2/snewpy/python/snewpy/models/base.py:305: RuntimeWarning: divide by zero encountered in log\n",
+      "  np.exp(np.log(L) - (2+a)*np.log(Ea) + (1+a)*np.log(1+a)\n",
+      "/home/ash/work/snews2/snewpy/python/snewpy/models/base.py:305: RuntimeWarning: invalid value encountered in subtract\n",
+      "  np.exp(np.log(L) - (2+a)*np.log(Ea) + (1+a)*np.log(1+a)\n",
+      "/home/ash/work/snews2/snewpy/python/snewpy/models/base.py:306: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  - loggamma(1+a) + a*np.log(E) - (1+a)*(E/Ea)) / (u.erg * u.s)\n"
+     ]
+    }
+   ],
+   "source": [
+    "flux = model.get_flux(t = times, E = energies, distance=10<<u.kpc)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "be256bc2-3707-47bd-ab15-173eb46cb98f",
+   "metadata": {},
+   "source": [
+    "## Working with the Container class\n",
+    "\n",
+    "The container class is defined in `snewpy.flux.Container`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "56fa3f27-ce67-459f-a2dd-7f5e32713ab5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\u001b[0;31mInit signature:\u001b[0m\n",
+       "\u001b[0mContainer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mdata\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mastropy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munits\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mquantity\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mQuantity\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mflavor\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msnewpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mneutrino\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFlavor\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mtime\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtyping\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAnnotated\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mastropy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munits\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mquantity\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mQuantity\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mUnit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"s\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0menergy\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtyping\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAnnotated\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mastropy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munits\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mquantity\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mQuantity\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mUnit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"MeV\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0;34m*\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mintegrable_axes\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mSet\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msnewpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflux\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+       "\u001b[0;31mDocstring:\u001b[0m     \n",
+       "base class for internal use\n",
+       ":noindex:\n",
+       "\u001b[0;31mInit docstring:\u001b[0m\n",
+       "A container class storing the physical quantity (flux, fluence, rate...), which depends on flavor, time and energy.\n",
+       "\n",
+       "Parameters\n",
+       "----------\n",
+       "data: :class:`astropy.Quantity`\n",
+       "    3D array of the stored quantity, must have dimensions compatible with (flavor, time, energy)\n",
+       "\n",
+       "flavor: list of :class:`snewpy.neutrino.Flavor`\n",
+       "    array of flavors (should be ``len(flavor)==data.shape[0]``\n",
+       "\n",
+       "time: array of :class:`astropy.Quantity`\n",
+       "    sampling points in time (then ``len(time)==data.shape[1]``) \n",
+       "    or time bin edges (then ``len(time)==data.shape[1]+1``) \n",
+       "\n",
+       "energy: array of :class:`astropy.Quantity`\n",
+       "    sampling points in energy (then ``len(energy)=data.shape[2]``) \n",
+       "    or energy bin edges (then ``len(energy)=data.shape[2]+1``) \n",
+       "\n",
+       "integrable_axes: set of :class:`Axes` or None\n",
+       "    List of axes which can be integrated.\n",
+       "    If None (default) this set will be derived from the axes shapes \n",
+       "\u001b[0;31mFile:\u001b[0m           ~/work/snews2/snewpy/python/snewpy/flux.py\n",
+       "\u001b[0;31mType:\u001b[0m           type\n",
+       "\u001b[0;31mSubclasses:\u001b[0m     d2FdEdT, dFdE, dFdT, dF, d2NdEdT, dNdT, dNdE, N\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from snewpy.flux import Container\n",
+    "\n",
+    "Container?"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "2597b62d-a0e4-4708-b9ea-7c7a10df1618",
+   "metadata": {},
+   "source": [
+    "### Inspection\n",
+    "\n",
+    "We will use the flux container, obtained from the SupernovaModel on the previous step.\n",
+    "\n",
+    "On print the Container gives an output, describing it's `array` dimensions, unit (here it's `[1/(cm2 MeV s)]`), and the range of each of three axes: `flavor`, `time` and `energy`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "9875d016-6ce3-4870-aec9-7b845956e7f4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "d2FdEdT (4, 9850, 501) [1 / (cm2 MeV s)]: <4 flavor(0;3) x 9850 time(-0.34462761827 s;8.350202515285 s) x 501 energy(0.0 MeV;50.0 MeV)>\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(flux)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a042f15-0064-4867-a2f8-e552d74dab71",
+   "metadata": {},
+   "source": [
+    "One can access the array, as a `astropy.Quantity` object:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "14e70ce5-1eaf-4a06-8c0d-4f53d85e5f9e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$[[[0,~0,~0,~\\dots,~0,~0,~0],~\n",
+       "  [0,~0,~0,~\\dots,~0,~0,~0],~\n",
+       "  [0,~0,~0,~\\dots,~0,~0,~0],~\n",
+       "  \\dots,~\n",
+       "  [2.2228783 \\times 10^{-30},~328867.82,~1661738.5,~\\dots,~235.53378,~226.35226,~217.52655],~\n",
+       "  [2.1604194 \\times 10^{-30},~327965.91,~1658039.4,~\\dots,~234.64623,~225.49703,~216.70248],~\n",
+       "  [2.1032997 \\times 10^{-30},~327240.02,~1655180.5,~\\dots,~233.4129,~224.3087,~215.55753]],~\n",
+       "\n",
+       " [[0,~0,~0,~\\dots,~0,~0,~0],~\n",
+       "  [0,~0,~0,~\\dots,~0,~0,~0],~\n",
+       "  [0,~0,~0,~\\dots,~0,~0,~0],~\n",
+       "  \\dots,~\n",
+       "  [1.4388622 \\times 10^{-29},~357850.9,~1745058.8,~\\dots,~321.73118,~309.50268,~297.73615],~\n",
+       "  [1.4007637 \\times 10^{-29},~356928.82,~1741410.6,~\\dots,~320.53885,~308.35264,~296.62692],~\n",
+       "  [1.3622432 \\times 10^{-29},~356097.73,~1738242.5,~\\dots,~318.91386,~306.78529,~295.11519]],~\n",
+       "\n",
+       " [[1.066313 \\times 10^{-142},~4.1433464 \\times 10^{-13},~1.566693 \\times 10^{-10},~\\dots,~3.8754761 \\times 10^{-32},~3.2338573 \\times 10^{-32},~2.6983682 \\times 10^{-32}],~\n",
+       "  [2.8609441 \\times 10^{-77},~94.11815,~3230.194,~\\dots,~1.4098028 \\times 10^{-23},~1.1878837 \\times 10^{-23},~1.0008757 \\times 10^{-23}],~\n",
+       "  [1.4689323 \\times 10^{-75},~284.80835,~9288.5529,~\\dots,~9.4678615 \\times 10^{-22},~8.0345105 \\times 10^{-22},~6.8180117 \\times 10^{-22}],~\n",
+       "  \\dots,~\n",
+       "  [1.2754846 \\times 10^{-34},~161654.43,~978281.81,~\\dots,~34.768516,~33.23863,~31.775721],~\n",
+       "  [1.2454354 \\times 10^{-34},~161255.36,~976287.3,~\\dots,~34.675913,~33.149868,~31.690643],~\n",
+       "  [1.242386 \\times 10^{-34},~161232.14,~976187.72,~\\dots,~34.590376,~33.067917,~31.612129]],~\n",
+       "\n",
+       " [[0,~0,~0,~\\dots,~0,~0,~0],~\n",
+       "  [0,~0,~0,~\\dots,~0,~0,~0],~\n",
+       "  [0,~0,~0,~\\dots,~0,~0,~0],~\n",
+       "  \\dots,~\n",
+       "  [2.2228783 \\times 10^{-30},~328867.82,~1661738.5,~\\dots,~235.53378,~226.35226,~217.52655],~\n",
+       "  [2.1604194 \\times 10^{-30},~327965.91,~1658039.4,~\\dots,~234.64623,~225.49703,~216.70248],~\n",
+       "  [2.1032997 \\times 10^{-30},~327240.02,~1655180.5,~\\dots,~233.4129,~224.3087,~215.55753]]] \\; \\mathrm{\\frac{1}{MeV\\,s\\,cm^{2}}}$"
+      ],
+      "text/plain": [
+       "<Quantity [[[0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n",
+       "             0.00000000e+000, 0.00000000e+000, 0.00000000e+000],\n",
+       "            [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n",
+       "             0.00000000e+000, 0.00000000e+000, 0.00000000e+000],\n",
+       "            [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n",
+       "             0.00000000e+000, 0.00000000e+000, 0.00000000e+000],\n",
+       "            ...,\n",
+       "            [2.22287829e-030, 3.28867822e+005, 1.66173852e+006, ...,\n",
+       "             2.35533785e+002, 2.26352262e+002, 2.17526554e+002],\n",
+       "            [2.16041937e-030, 3.27965908e+005, 1.65803938e+006, ...,\n",
+       "             2.34646226e+002, 2.25497028e+002, 2.16702481e+002],\n",
+       "            [2.10329974e-030, 3.27240025e+005, 1.65518049e+006, ...,\n",
+       "             2.33412904e+002, 2.24308702e+002, 2.15557527e+002]],\n",
+       "\n",
+       "           [[0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n",
+       "             0.00000000e+000, 0.00000000e+000, 0.00000000e+000],\n",
+       "            [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n",
+       "             0.00000000e+000, 0.00000000e+000, 0.00000000e+000],\n",
+       "            [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n",
+       "             0.00000000e+000, 0.00000000e+000, 0.00000000e+000],\n",
+       "            ...,\n",
+       "            [1.43886217e-029, 3.57850901e+005, 1.74505885e+006, ...,\n",
+       "             3.21731179e+002, 3.09502677e+002, 2.97736153e+002],\n",
+       "            [1.40076374e-029, 3.56928822e+005, 1.74141061e+006, ...,\n",
+       "             3.20538852e+002, 3.08352639e+002, 2.96626922e+002],\n",
+       "            [1.36224324e-029, 3.56097725e+005, 1.73824251e+006, ...,\n",
+       "             3.18913860e+002, 3.06785289e+002, 2.95115193e+002]],\n",
+       "\n",
+       "           [[1.06631302e-142, 4.14334641e-013, 1.56669299e-010, ...,\n",
+       "             3.87547612e-032, 3.23385731e-032, 2.69836819e-032],\n",
+       "            [2.86094411e-077, 9.41181503e+001, 3.23019399e+003, ...,\n",
+       "             1.40980276e-023, 1.18788371e-023, 1.00087570e-023],\n",
+       "            [1.46893235e-075, 2.84808350e+002, 9.28855290e+003, ...,\n",
+       "             9.46786151e-022, 8.03451049e-022, 6.81801166e-022],\n",
+       "            ...,\n",
+       "            [1.27548460e-034, 1.61654430e+005, 9.78281808e+005, ...,\n",
+       "             3.47685161e+001, 3.32386299e+001, 3.17757211e+001],\n",
+       "            [1.24543543e-034, 1.61255359e+005, 9.76287300e+005, ...,\n",
+       "             3.46759127e+001, 3.31498679e+001, 3.16906426e+001],\n",
+       "            [1.24238596e-034, 1.61232142e+005, 9.76187718e+005, ...,\n",
+       "             3.45903765e+001, 3.30679175e+001, 3.16121289e+001]],\n",
+       "\n",
+       "           [[0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n",
+       "             0.00000000e+000, 0.00000000e+000, 0.00000000e+000],\n",
+       "            [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n",
+       "             0.00000000e+000, 0.00000000e+000, 0.00000000e+000],\n",
+       "            [0.00000000e+000, 0.00000000e+000, 0.00000000e+000, ...,\n",
+       "             0.00000000e+000, 0.00000000e+000, 0.00000000e+000],\n",
+       "            ...,\n",
+       "            [2.22287829e-030, 3.28867822e+005, 1.66173852e+006, ...,\n",
+       "             2.35533785e+002, 2.26352262e+002, 2.17526554e+002],\n",
+       "            [2.16041937e-030, 3.27965908e+005, 1.65803938e+006, ...,\n",
+       "             2.34646226e+002, 2.25497028e+002, 2.16702481e+002],\n",
+       "            [2.10329974e-030, 3.27240025e+005, 1.65518049e+006, ...,\n",
+       "             2.33412904e+002, 2.24308702e+002, 2.15557527e+002]]] 1 / (cm2 MeV s)>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "flux.array"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "090625ec-7ab1-4f4a-8a36-4865328660d0",
+   "metadata": {},
+   "source": [
+    "and individual axes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "73c1a777-426e-460d-bdeb-31ddf9db68df",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$[0,~0.1,~0.2,~\\dots,~49.8,~49.9,~50] \\; \\mathrm{MeV}$"
+      ],
+      "text/plain": [
+       "<Quantity [ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9,\n",
+       "            1. ,  1.1,  1.2,  1.3,  1.4,  1.5,  1.6,  1.7,  1.8,  1.9,\n",
+       "            2. ,  2.1,  2.2,  2.3,  2.4,  2.5,  2.6,  2.7,  2.8,  2.9,\n",
+       "            3. ,  3.1,  3.2,  3.3,  3.4,  3.5,  3.6,  3.7,  3.8,  3.9,\n",
+       "            4. ,  4.1,  4.2,  4.3,  4.4,  4.5,  4.6,  4.7,  4.8,  4.9,\n",
+       "            5. ,  5.1,  5.2,  5.3,  5.4,  5.5,  5.6,  5.7,  5.8,  5.9,\n",
+       "            6. ,  6.1,  6.2,  6.3,  6.4,  6.5,  6.6,  6.7,  6.8,  6.9,\n",
+       "            7. ,  7.1,  7.2,  7.3,  7.4,  7.5,  7.6,  7.7,  7.8,  7.9,\n",
+       "            8. ,  8.1,  8.2,  8.3,  8.4,  8.5,  8.6,  8.7,  8.8,  8.9,\n",
+       "            9. ,  9.1,  9.2,  9.3,  9.4,  9.5,  9.6,  9.7,  9.8,  9.9,\n",
+       "           10. , 10.1, 10.2, 10.3, 10.4, 10.5, 10.6, 10.7, 10.8, 10.9,\n",
+       "           11. , 11.1, 11.2, 11.3, 11.4, 11.5, 11.6, 11.7, 11.8, 11.9,\n",
+       "           12. , 12.1, 12.2, 12.3, 12.4, 12.5, 12.6, 12.7, 12.8, 12.9,\n",
+       "           13. , 13.1, 13.2, 13.3, 13.4, 13.5, 13.6, 13.7, 13.8, 13.9,\n",
+       "           14. , 14.1, 14.2, 14.3, 14.4, 14.5, 14.6, 14.7, 14.8, 14.9,\n",
+       "           15. , 15.1, 15.2, 15.3, 15.4, 15.5, 15.6, 15.7, 15.8, 15.9,\n",
+       "           16. , 16.1, 16.2, 16.3, 16.4, 16.5, 16.6, 16.7, 16.8, 16.9,\n",
+       "           17. , 17.1, 17.2, 17.3, 17.4, 17.5, 17.6, 17.7, 17.8, 17.9,\n",
+       "           18. , 18.1, 18.2, 18.3, 18.4, 18.5, 18.6, 18.7, 18.8, 18.9,\n",
+       "           19. , 19.1, 19.2, 19.3, 19.4, 19.5, 19.6, 19.7, 19.8, 19.9,\n",
+       "           20. , 20.1, 20.2, 20.3, 20.4, 20.5, 20.6, 20.7, 20.8, 20.9,\n",
+       "           21. , 21.1, 21.2, 21.3, 21.4, 21.5, 21.6, 21.7, 21.8, 21.9,\n",
+       "           22. , 22.1, 22.2, 22.3, 22.4, 22.5, 22.6, 22.7, 22.8, 22.9,\n",
+       "           23. , 23.1, 23.2, 23.3, 23.4, 23.5, 23.6, 23.7, 23.8, 23.9,\n",
+       "           24. , 24.1, 24.2, 24.3, 24.4, 24.5, 24.6, 24.7, 24.8, 24.9,\n",
+       "           25. , 25.1, 25.2, 25.3, 25.4, 25.5, 25.6, 25.7, 25.8, 25.9,\n",
+       "           26. , 26.1, 26.2, 26.3, 26.4, 26.5, 26.6, 26.7, 26.8, 26.9,\n",
+       "           27. , 27.1, 27.2, 27.3, 27.4, 27.5, 27.6, 27.7, 27.8, 27.9,\n",
+       "           28. , 28.1, 28.2, 28.3, 28.4, 28.5, 28.6, 28.7, 28.8, 28.9,\n",
+       "           29. , 29.1, 29.2, 29.3, 29.4, 29.5, 29.6, 29.7, 29.8, 29.9,\n",
+       "           30. , 30.1, 30.2, 30.3, 30.4, 30.5, 30.6, 30.7, 30.8, 30.9,\n",
+       "           31. , 31.1, 31.2, 31.3, 31.4, 31.5, 31.6, 31.7, 31.8, 31.9,\n",
+       "           32. , 32.1, 32.2, 32.3, 32.4, 32.5, 32.6, 32.7, 32.8, 32.9,\n",
+       "           33. , 33.1, 33.2, 33.3, 33.4, 33.5, 33.6, 33.7, 33.8, 33.9,\n",
+       "           34. , 34.1, 34.2, 34.3, 34.4, 34.5, 34.6, 34.7, 34.8, 34.9,\n",
+       "           35. , 35.1, 35.2, 35.3, 35.4, 35.5, 35.6, 35.7, 35.8, 35.9,\n",
+       "           36. , 36.1, 36.2, 36.3, 36.4, 36.5, 36.6, 36.7, 36.8, 36.9,\n",
+       "           37. , 37.1, 37.2, 37.3, 37.4, 37.5, 37.6, 37.7, 37.8, 37.9,\n",
+       "           38. , 38.1, 38.2, 38.3, 38.4, 38.5, 38.6, 38.7, 38.8, 38.9,\n",
+       "           39. , 39.1, 39.2, 39.3, 39.4, 39.5, 39.6, 39.7, 39.8, 39.9,\n",
+       "           40. , 40.1, 40.2, 40.3, 40.4, 40.5, 40.6, 40.7, 40.8, 40.9,\n",
+       "           41. , 41.1, 41.2, 41.3, 41.4, 41.5, 41.6, 41.7, 41.8, 41.9,\n",
+       "           42. , 42.1, 42.2, 42.3, 42.4, 42.5, 42.6, 42.7, 42.8, 42.9,\n",
+       "           43. , 43.1, 43.2, 43.3, 43.4, 43.5, 43.6, 43.7, 43.8, 43.9,\n",
+       "           44. , 44.1, 44.2, 44.3, 44.4, 44.5, 44.6, 44.7, 44.8, 44.9,\n",
+       "           45. , 45.1, 45.2, 45.3, 45.4, 45.5, 45.6, 45.7, 45.8, 45.9,\n",
+       "           46. , 46.1, 46.2, 46.3, 46.4, 46.5, 46.6, 46.7, 46.8, 46.9,\n",
+       "           47. , 47.1, 47.2, 47.3, 47.4, 47.5, 47.6, 47.7, 47.8, 47.9,\n",
+       "           48. , 48.1, 48.2, 48.3, 48.4, 48.5, 48.6, 48.7, 48.8, 48.9,\n",
+       "           49. , 49.1, 49.2, 49.3, 49.4, 49.5, 49.6, 49.7, 49.8, 49.9,\n",
+       "           50. ] MeV>"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "flux.energy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "157275e0-afa0-4f74-95ed-969fcc52138c",
+   "metadata": {},
+   "source": [
+    "### Slicing\n",
+    "\n",
+    "Flux can be sliced the same way as a usual np.array:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "9c163ad6-ba5f-4ed3-90bf-7df55114659e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "d2FdEdT (1, 9850, 501) [1 / (cm2 MeV s)]: <1 flavor(2;2) x 9850 time(-0.34462761827 s;8.350202515285 s) x 501 energy(0.0 MeV;50.0 MeV)>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#get the flux for specific flavor\n",
+    "flux[Flavor.NU_E] "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "33d054eb-38af-48f5-8463-095a865a6f3d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "d2FdEdT (4, 1000, 501) [1 / (cm2 MeV s)]: <4 flavor(0;3) x 1000 time(-0.34462761827 s;0.395847790315 s) x 501 energy(0.0 MeV;50.0 MeV)>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Or a trim the time or energy dimensions, \n",
+    "#here we take first 1000 points in time\n",
+    "flux[:,:1000,:]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cdae9fde-3eda-40d3-a195-db515009dc57",
+   "metadata": {},
+   "source": [
+    "### Summation\n",
+    "\n",
+    "Container can be summed by any of the axes: `flavor`,`time`,`energy`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "fae0f38e-3918-4744-9c61-22dea8171c26",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "d2FdEdT (1, 9850, 501) [1 / (cm2 MeV s)]: <2 flavor(0;3) x 9850 time(-0.34462761827 s;8.350202515285 s) x 501 energy(0.0 MeV;50.0 MeV)>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Sum over all flavors\n",
+    "flux.sum('flavor')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "2f5ebc14-eb05-4c10-ad9e-a69521147804",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ValueError: Cannot sum over time! Valid axes are {<Axes.flavor: 0>}\n"
+     ]
+    }
+   ],
+   "source": [
+    "#trying to summ over time or flavor will raise an exception\n",
+    "with raises(ValueError):\n",
+    "    flux.sum('time')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2505e6d4-3d5b-41d1-af3e-22c55f51f8ef",
+   "metadata": {},
+   "source": [
+    "### Integration\n",
+    "Also it can be integrated (using linear interpolation between points)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "a05eecb0-e29f-42c8-9574-41a5803e54d1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dFdT (4, 9850, 1) [1 / (cm2 s)]: <4 flavor(0;3) x 9850 time(-0.34462761827 s;8.350202515285 s) x 2 energy(0.0 MeV;50.0 MeV)>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Integrate over the full range, if limits are not provided\n",
+    "flux.integrate('energy')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "e7731b3c-7c78-44f6-80c8-a6b28759e4a1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dFdE (4, 1, 501) [1 / (cm2 MeV)]: <4 flavor(0;3) x 2 time(0.0 s;1.0 s) x 501 energy(0.0 MeV;50.0 MeV)>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Integrate over the first second of the flux\n",
+    "flux.integrate('time',limits=[0,1]<<u.s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "4b0f2ff2-9679-4c34-a47a-f14dcfcbfadf",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dFdE (4, 3, 501) [1 / (cm2 MeV)]: <4 flavor(0;3) x 4 time(0.0 s;3.0 s) x 501 energy(0.0 MeV;50.0 MeV)>"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Integrate over the several time bins\n",
+    "flux.integrate('time',limits=[0,1,2,3]<<u.s)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d4756744-1f3d-4eeb-9108-4dab83e7b974",
+   "metadata": {},
+   "source": [
+    "After integration, the time dimension of the array here is `len(limits)-1`\n",
+    "But the corresponding axis (in this case `time`) keeps all the limits (and here it has 4 points)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fec77ea8-92a4-4df4-bdc0-757109045316",
+   "metadata": {},
+   "source": [
+    "### \"Summable\" and \"integrable\" axes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cb00b8c4-6af4-47af-b353-fcda7c6d1460",
+   "metadata": {},
+   "source": [
+    "Container will automatically watch which axes can be integrated, and which can only be summed over.\n",
+    "\n",
+    "For example, the flux, obtained from the `SupernovaModel.get_flux` is differential over time and energy, which means it can be integrated over `energy` and `time`. \n",
+    "You can see it from the class name `d2FdEdT` and the unit:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "7efae0e2-973d-4957-a300-2a2ce8e3c81d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "d2FdEdT (4, 9850, 501) [1 / (cm2 MeV s)]: <4 flavor(0;3) x 9850 time(-0.34462761827 s;8.350202515285 s) x 501 energy(0.0 MeV;50.0 MeV)>"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "flux"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a1f05316-4182-4bc9-8fdd-539a6f4f491c",
+   "metadata": {},
+   "source": [
+    "Internally the axes which can be summed or integrated are kept in the private properties:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "4c7e58cb-9a2d-43bf-830c-4aca0fce8d53",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Can integrate over {<Axes.time: 1>, <Axes.energy: 2>}\n",
+      "Can sum over {<Axes.flavor: 0>}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f'Can integrate over {flux._integrable_axes}')\n",
+    "print(f'Can sum over {flux._sumable_axes}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2e582855-9510-4173-b985-06bd1c02f32e",
+   "metadata": {},
+   "source": [
+    "After the integration over the axis, it becomes \"summable\":"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "557dd45d-5a0a-41d6-bc1b-6ccc99d22672",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Can integrate over {<Axes.energy: 2>}\n",
+      "Can sum over {<Axes.flavor: 0>, <Axes.time: 1>}\n"
+     ]
+    }
+   ],
+   "source": [
+    "fI = flux.integrate('time',limits=[0,1,2,3]<<u.s)\n",
+    "print(f'Can integrate over {fI._integrable_axes}')\n",
+    "print(f'Can sum over {fI._sumable_axes}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "c5fdfc31-35cd-440e-bb6d-799d2255eca3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dFdE (4, 1, 501) [1 / (cm2 MeV)]: <4 flavor(0;3) x 2 time(0.0 s;3.0 s) x 501 energy(0.0 MeV;50.0 MeV)>"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#after we integrated over time we can sum over the time bins\n",
+    "fI.sum('time')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "e1c7219f-533d-4247-9253-ee25a6ea886a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ValueError: Cannot integrate over time! Valid axes are {<Axes.energy: 2>}\n"
+     ]
+    }
+   ],
+   "source": [
+    "#but cannot integrate over time again\n",
+    "with raises(ValueError):\n",
+    "    fI.integrate('time')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "110ebf3c-8695-4a04-b75f-71bd20d157c3",
+   "metadata": {},
+   "source": [
+    "**Note**: *integration changes the physical unit, summation or slicing do not*"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "be55171e-8e29-4501-92f1-76a102601be7",
+   "metadata": {},
+   "source": [
+    "### Integrate or sum (project?)\n",
+    "\n",
+    "Sometimes you just want a projection of your flux to a specific axis (say, time).\n",
+    "In this case you want to integrate over energy if it's integrable, or just sum over the energy bins, if it is already integral flux:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "0f1c6cf1-7fc1-4068-9318-8a4eaea7fed4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert fI.integrate_or_sum('energy') == fI.integrate('energy')\n",
+    "assert fI.integrate_or_sum('time') == fI.sum('time')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f89102c-f2c9-4507-9fa2-fac0d4a36f51",
+   "metadata": {},
+   "source": [
+    "## 3. Calculate rate"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "792a8624-1236-45d1-9225-84ae22a51e26",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "I made a `RateCalculator` -  subclass of a `SimpleRate` (temporary solution for cleanness, we might merge them later).\n",
+    "\n",
+    "The main difference - it uses `RateCalculator.run` function to calculate rates - multiplying flux by the cross-section, target number, smearing matrix and efficiency.\n",
+    "\n",
+    "**Note** on the rate calculation:\n",
+    "In `SimpleRate` we used an input from `generate_fluence`, so the flux was already integrated within the energy bins, and the cross-section was sampled in the centers of energy bins.\n",
+    "\n",
+    "In the `RateCalculator` we're multiplying the flux by the cross-section, and only after that we integrate over energy bins, so that should be more precise."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "27151730-3463-40a2-89ed-1a62d92e3473",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from snewpy.rate_calculator import RateCalculator\n",
+    "rc = RateCalculator()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "c993b25d-1f03-4946-b277-ea7d2428e9d8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ash/work/snews2/snewpy/python/snewpy/rate_calculator.py:42: RuntimeWarning: divide by zero encountered in log\n",
+      "  xsecs = np.interp(np.log(E)/np.log(10), xp, yp, left=0, right=0)*E*1e-38 <<u.cm**2\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Container[cm2 / (cm2 s)] (1, 9850, 200) [cm2 / (cm2 s)]: <1 flavor(1;1) x 9850 time(-0.34462761827 s;8.350202515285 s) x 201 energy(0.0005 GeV;0.1 GeV)>"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#calculate time differential rate \n",
+    "rates = rc.run(flux, 'icecube')\n",
+    "rates['ibd']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8f4367c3-03c7-4232-926c-834151baf3c0",
+   "metadata": {},
+   "source": [
+    "`RateCalculator.run` outputs a dictionary of Container objects with rates for each channel"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9b290e09-a866-4c5a-9811-7e4c92c67696",
+   "metadata": {},
+   "source": [
+    "Since rhe rate calculation only operates on energy, the time structure remains the same: if it was flux (`1/(MeV cm2 s)`) the rate will be `1/s`\n",
+    "\n",
+    "But if we pass a flux integrated over time (fluence), we get just number of events:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "d7b56248-b368-4712-9c50-208cc2f58415",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Container[cm2 / cm2] (1, 20, 200) [cm2 / cm2]: <1 flavor(1;1) x 21 time(0.0 s;2.0 s) x 201 energy(0.0005 GeV;0.1 GeV)>"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#calculate time integral rate \n",
+    "fluence = flux.integrate('time', np.arange(0,2.1,0.1)<<u.s)\n",
+    "ratesI = rc.run(fluence, 'icecube')\n",
+    "ratesI['ibd']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91a8fd49-5feb-422a-8eb3-f297fbc61a6f",
+   "metadata": {},
+   "source": [
+    "### Saving and loading"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "32a3957b-9e5c-4f76-9e18-75b7b9cd774c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dFdE (4, 20, 501) [1 / (cm2 MeV)]: <4 flavor(0;3) x 21 time(0.0 s;2.0 s) x 501 energy(0.0 MeV;50.0 MeV)>"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Container can be saved to a file \n",
+    "fluence.save('fluence.npz')\n",
+    "#and loaded using the class method\n",
+    "fluence1 = Container.load('fluence.npz')\n",
+    "assert fluence1 == fluence\n",
+    "\n",
+    "fluence1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c8612f45-6415-4a3c-93f8-3a320572ef60",
+   "metadata": {},
+   "source": [
+    "## 4. Plotting examples"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2277f47-fe03-4047-815c-a8ed22edffa2",
+   "metadata": {},
+   "source": [
+    "### Utility functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "95972dcf-7a45-4df8-9a36-826d1ec39f26",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Utility function to draw the flux\n",
+    "from snewpy.flux import Axes\n",
+    "\n",
+    "def project(flux, axis, integrate=True):\n",
+    "    axis = Axes[axis] #convert to enum\n",
+    "    integrate_axis = Axes.time \n",
+    "    if axis == integrate_axis:\n",
+    "        integrate_axis = Axes.energy \n",
+    "    fI = (flux.integrate if integrate else flux.sum)(integrate_axis)\n",
+    "    return fI.axes[axis], fI\n",
+    "    \n",
+    "def plot_projection(flux, axis, step=False, integrate=True):\n",
+    "    x,fI = project(flux,axis, integrate)\n",
+    "    y = fI.array.squeeze().T\n",
+    "    if step:\n",
+    "        #we're dealing with bins, not points\n",
+    "        l = plt.step(x[:-1], y, where='pre', label=[Flavor(flv).to_tex() for flv in flux.flavor])\n",
+    "    else:\n",
+    "        l = plt.plot(x, y, label=[Flavor(flv).to_tex() for flv in flux.flavor])\n",
+    "    \n",
+    "    plt.ylabel(f'{fI.__class__.__name__},  {y.unit}')\n",
+    "    plt.xlabel(f'{Axes[axis].name},  {x.unit}')\n",
+    "    return l"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "57954135-8721-400c-898e-3a36f7b4bf37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Utility function to draw the \n",
+    "def plot_rates(rates):\n",
+    "    for ch,r in rates.items():\n",
+    "        rT = r.sum('energy')\n",
+    "\n",
+    "        plt.plot(rT.time, rT.array.squeeze(), label=ch)\n",
+    "    #plt.xlim(right=0.5)\n",
+    "    plt.ylabel(f'{rT.__class__.__name__},  {r.array.unit}')\n",
+    "    plt.xlabel(f'time, {rT.time.unit}')\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4565d348-c340-4281-a12f-120e99d3314e",
+   "metadata": {},
+   "source": [
+    "### Plot fluxes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "78b18cba-8d8c-44d2-bfd9-1e7a0dd418f3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#plot the neutrino flux \n",
+    "fig,ax = plt.subplots(1,2, figsize=(12,6))\n",
+    "plt.sca(ax[0])\n",
+    "plot_projection(flux, 'energy', integrate=True)\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.sca(ax[1])\n",
+    "plot_projection(flux, 'time', integrate=True)\n",
+    "plt.legend()\n",
+    "plt.xscale('log')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "0dab79aa-b9a1-4b73-bf4b-86707ffc253e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 748.8x514.8 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for ch, rate in rates.items():\n",
+    "    l = plot_projection(rate, 'time', integrate=False)\n",
+    "    l[0].set_label(ch)\n",
+    "plt.yscale('log')\n",
+    "plt.legend(loc='right')\n",
+    "plt.ylim(0.1)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "c5b932d5-7d31-49eb-a1ab-c44afc50c89f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 748.8x514.8 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for ch, rate in ratesI.items():\n",
+    "    l = plot_projection(rate, 'time', integrate=False, step=True)\n",
+    "    l[0].set_label(ch)\n",
+    "plt.yscale('log')\n",
+    "plt.legend(loc='right')\n",
+    "plt.ylim(0.1)\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.10.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/doc/source/flux.rst b/doc/source/flux.rst
new file mode 100644
index 0000000..c9783ff
--- /dev/null
+++ b/doc/source/flux.rst
@@ -0,0 +1,14 @@
+Interface for flux and rate calculation
+=======================================
+
+.. note::
+    Users should consider using high-level interface, provided by :mod:`snewpy.snowglobes`
+    This low-level interface is not guaranteed to be stable and may change at any time without warning.
+
+Flux containers
+---------------
+.. automodule:: snewpy.flux
+
+Rate calcuation
+---------------
+.. automodule:: snewpy.rate_calculator
diff --git a/doc/source/index.rst b/doc/source/index.rst
index 2537559..c0a238e 100644
--- a/doc/source/index.rst
+++ b/doc/source/index.rst
@@ -23,6 +23,7 @@ Table of Contents
    models
    transformations
    neutrino
+   flux
    contributing
    citing
 
diff --git a/python/snewpy/flux.py b/python/snewpy/flux.py
new file mode 100644
index 0000000..7991007
--- /dev/null
+++ b/python/snewpy/flux.py
@@ -0,0 +1,381 @@
+"""
+The module :mod:`snewpy.flux` defines the class :class:`snewpy.flux.Container` - a container for the neutrino flux, fluence, event rates etc.
+
+This object wraps a 3D array, and its dimensions: `flavor`, `time` and `energy`.
+
+Usage
+-----
+The flux container will be produced by the :meth:`SupernovaModel.get_flux`, and consumed by the :meth:`RateCalculator.run`
+
+A example of usage:
+
+.. code-block:: python
+
+    import astropy.units as u
+    import numpy as np
+    from snewpy.models import ccsn
+    from snewpy.flavor_transformation import AdiabaticMSW
+    
+    #get the suernova model
+    model = ccsn.Bollig_2016(progenitor_mass=27<<u.Msun)
+    #define the sampling points
+    energy = np.linspace(0,100,51)<<u.MeV
+    time = np.linspace(0,10,1000)<<u.s
+    
+    #calculate the flux
+    flux = model.get_flux(time, energy, distance=10<<u.kpc, flavor_xform=AdiabaticMSW())
+
+    #optionally: integrate the flux over time bins to obtain the fluence
+    fluence = flux.integrate('time', limits=np.linspace(0,1,21)<<u.s)
+    
+    #calculate the event rates using the RateCalculator
+    from snewpy.rate_calculator import RateCalculator
+    rc = RateCalculator()
+    event_rates = rc.run(fluence, detector='icecube')
+    ibd_rate = event_rates['ibd'] #will be also a Container instance
+    #get the total values vs. time bin
+    N_ibd_vs_T = ibd_rate.sum('energy')
+    #or total values vs. energy bin
+    N_ibd_vs_E = ibd_rate.sum('time')
+    #or total number of interactions
+    N_ibd_tot = ibd_rate.sum('time').sum('energy')
+    #to retrieve the number we can access the `array` member
+    print(N_ibd_tot.array.squeeze()) #312249.3525844854
+
+Reference
+---------
+
+.. autoclass:: Container
+    :inherited-members:
+
+.. autoclass:: Axes
+
+"""
+from typing import Union, Optional, Set, List
+from snewpy.neutrino import Flavor
+from astropy import units as u
+
+import numpy as np
+
+from scipy.integrate import cumulative_trapezoid
+from scipy.interpolate import interp1d
+from enum import IntEnum
+
+from copy import copy
+from functools import wraps
+
+class Axes(IntEnum):
+    """Enum to keep the number number of the array dimension for each axis""" 
+    flavor=0, #Flavor dimension
+    time=1,   #Time dimension
+    energy=2, #Energy dimension
+    
+    @classmethod
+    def get(cls, value:Union['Axes',int,str])->'Axes':
+        "convert string,int or Axes value to Axes"
+        if isinstance(value,str):
+            return cls[value]
+        else:
+            return cls(value)
+
+class _ContainerBase:
+    """base class for internal use
+    :noindex:
+    """
+    unit = None
+    def __init__(self, 
+                 data: u.Quantity,
+                 flavor: List[Flavor],
+                 time: u.Quantity[u.s], 
+                 energy: u.Quantity[u.MeV],
+                 *,
+                 integrable_axes: Optional[Set[Axes]] = None
+    ):
+        """A container class storing the physical quantity (flux, fluence, rate...), which depends on flavor, time and energy.
+
+        Parameters
+        ----------
+        data: :class:`astropy.Quantity`
+            3D array of the stored quantity, must have dimensions compatible with (flavor, time, energy)
+        
+        flavor: list of :class:`snewpy.neutrino.Flavor`
+            array of flavors (should be ``len(flavor)==data.shape[0]``
+        
+        time: array of :class:`astropy.Quantity`
+            sampling points in time (then ``len(time)==data.shape[1]``) 
+            or time bin edges (then ``len(time)==data.shape[1]+1``) 
+    
+        energy: array of :class:`astropy.Quantity`
+            sampling points in energy (then ``len(energy)=data.shape[2]``) 
+            or energy bin edges (then ``len(energy)=data.shape[2]+1``) 
+    
+        integrable_axes: set of :class:`Axes` or None
+            List of axes which can be integrated.
+            If None (default) this set will be derived from the axes shapes 
+        """
+        if self.unit is not None:
+            #try to convert to the unit
+            data = data.to(self.unit)
+        self.array = data
+        self.flavor = np.sort(flavor)
+        self.time = time
+        self.energy = energy
+        
+        if integrable_axes is not None:
+            #store which axes can be integrated
+            self._integrable_axes = set(integrable_axes)
+        else:
+            #guess which axes can be integrated
+            self._integrable_axes = {a for a in Axes if(self._axshape[a]==self.array.shape[a])}
+            self._integrable_axes.discard(Axes.flavor)
+            
+    @property
+    def _sumable_axes(self):
+        return set(Axes).difference(self._integrable_axes)
+    @property
+    def axes(self):
+        return self.flavor, self.time, self.energy
+
+    @property
+    def _axshape(self):
+        return tuple(len(a) for a in self.axes)
+
+    @property
+    def shape(self):
+        return self.array.shape
+        
+    def __getitem__(self, args)->'Container':
+        """Slice the flux array and produce a new Flux object"""
+        try: 
+            iter(args)
+        except TypeError:
+            args = [args]
+        args = [a if isinstance(a, slice) else slice(a, a + 1) for a in args]
+        #expand args to match axes
+        args+=[slice(None)]*(len(Axes)-len(args))
+        array = self.array.__getitem__(tuple(args))
+        newaxes = [ax.__getitem__(arg) for arg, ax in zip(args, self.axes)]
+        return self.__class__(array, *newaxes)
+
+    def __repr__(self) -> str:
+        """print information about the container"""
+        s = [f"{len(values)} {label.name}({values.min()};{values.max()})"
+            for label, values in zip(Axes,self.axes)]
+        return f"{self.__class__.__name__} {self.array.shape} [{self.array.unit}]: <{' x '.join(s)}>"
+    
+    def sum(self, axis: Union[Axes,str])->'Container':
+        """Sum along given axis, producing a Container with the summary quantity.
+        
+        Parameters
+        -----------
+            axis: :class:`Axes` or str
+                An axis to sum over. String should be one of ``"flavor"``, ``"time"`` or ``"energy"``  (check :meth:`Container.can_sum`)
+        Returns
+        --------
+            Container with summed value
+                
+        Raises
+        ------
+            ValueError 
+                if the given axis cannot be summed over (i.e. it must be integrated instead, see :meth:`Container.integrate`).
+                One can check summable axes with :attr:`Container._sumable_axes`
+
+        Example
+        -------
+        The resulting data array will be 3D array, but the dimension, corresponding to `axis` parameter will be reduced to 1. 
+        
+        For an examplar Container ``a`` of a given shape::
+        
+            >>> a.shape
+            (4, 10, 20)
+            >>> a.sum('flavor').shape
+            (1, 10, 20)
+        
+        The axis in the class will also be modified, keeping only the first and last points of the summation::
+        
+            >>> a.flavor
+            array([0, 1, 2, 3])
+            >>> a.sum('flavor').flavor
+            array([0, 3])
+            
+        All the other axes and dimensions will be kept the same
+        """
+        axis = Axes.get(axis)
+        if axis not in self._sumable_axes:
+            raise ValueError(f'Cannot sum over {axis.name}! Valid axes are {self._sumable_axes}')
+        array = np.sum(self.array, axis = axis, keepdims=True)
+        axes = list(self.axes)
+        axes[axis] = axes[axis].take([0,-1])
+        return Container(array,*axes, integrable_axes = self._integrable_axes.difference({axis}))
+
+    def integrate(self, axis:Union[Axes,str], limits:np.ndarray=None)->'Container':
+        """Integrate along given axis, producing a Container with the integral quantity.
+        
+        Parameters
+        -----------
+            axis: :class:`Axes` or str
+                An axis to integrate over. String should be one of ``"time"`` or ``"energy"`` (check :meth:`Container.can_integrate`)
+
+            limits: np.ndarray or None
+                A sorted array (or `astropy.Quantity` consistent with the units of given axis) of integration limits
+                If limits are None (default), then integrate over the the whole range of this axis
+                Otherwise limits are treated as bin edges - the integration  happens within each bin limits
+                
+        Returns
+        --------
+            Container with integrated value
+
+        Raises
+        ------
+            ValueError 
+                if the given axis cannot be integrated over (i.e. it must be summed instead, see :meth:`Container.sum`).
+        Example
+        -------
+        The resulting data array will be 3D array, but the dimension, corresponding to `axis` parameter will be reduced to ``len(limits)-1``. 
+        
+        For an examplar Container ``a`` of a given shape::
+        
+            >>> a.shape
+            (4, 10, 20)
+            >>> a.integrate('time').shape
+            (4, 1, 20)
+            >>> a.integrate('time', limits=[0, 0.5, 1]<<u.s).shape
+            (4, 2, 20)
+
+        The axis in the class will also be modified, keeping only the integration limits::
+        
+            >>> a.time
+            [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] s
+            >>> a.integrate('time').time
+            [0., 9.] s
+            >>> a.integrate('time', limits=[0, 0.5, 1]<<u.s).time
+            [0., 0.5, 1.] s
+        
+        All the other axes and dimensions will be kept the same
+        """
+        axis = Axes.get(axis)
+        if not axis in self._integrable_axes:
+            raise ValueError(f'Cannot integrate over {axis.name}! Valid axes are {self._integrable_axes}')
+        #set the limits
+        ax = self.axes[axis]
+        xmin, xmax = ax.min(), ax.max()
+        if limits is None:
+            limits = u.Quantity([xmin, xmax])
+        limits = limits.to(ax.unit)
+        limits = limits.clip(xmin, xmax)
+        #compute the integral
+        yc = cumulative_trapezoid(self.array, x=ax, axis=axis, initial=0)
+        _integral = interp1d(x=ax, y=yc, fill_value=0, axis=axis, bounds_error=False)
+        array = np.diff(_integral(limits),axis=axis) << (self.array.unit*ax.unit)
+        axes = list(self.axes)
+        axes[axis] = limits
+        #choose the proper class
+        return Container(array, *axes, integrable_axes=self._integrable_axes.difference({axis}))
+        return result
+        
+    def integrate_or_sum(self, axis:Union[Axes,str])->'Container':
+        if self.can_integrate(axis):
+            return self.integrate(axis)
+        else:
+            return self.sum(axis)
+            
+    def can_integrate(self, axis):
+        "return true if can be integrated along given axis"
+        return Axes.get(axis) in self._integrable_axes
+    def can_sum(self, axis):
+        "return true if can be summed along given axis"
+        return Axes.get(axis) not in self._integrable_axes
+    
+    def __rmul__(self, factor):
+        "multiply array by givem factor or matrix"
+        return self.__mul__(self, factor)
+
+    def __mul__(self, factor) -> 'Container':
+        "multiply array by givem factor or matrix"
+        #if not (np.isscalar(factor)):
+        #    raise ValueError("Factor should be a scalar value")
+        array = self.array*factor
+        axes = list(self.axes)
+        return Container(array, *axes)
+
+    def save(self, fname:str)->None:
+        """Save container data to a given file (using `numpy.savez`)"""
+        def _save_quantity(name):
+            values = self.__dict__[name]
+            try:
+                array = values.to_value()
+                unit = values.unit.to_string()
+                return {name:array, f'_{name}_unit':unit}
+            except:
+                return {name:values}
+        data_dict = {}
+        for name in ['array','time','energy','flavor']:
+            data_dict.update(_save_quantity(name))
+        np.savez(fname,
+                 _class_name=self.__class__.__name__, 
+                 **data_dict,
+                 _integrable_axes=np.array([int(a) for a in self._integrable_axes])
+                )
+    
+    @classmethod
+    def load(cls, fname:str)->'Container':
+        """Load container from a given file"""
+        with np.load(fname) as f:
+            def _load_quantity(name):
+                array = f[name]
+                try:
+                    unit = str(f[f'_{name}_unit'])
+                    return array<<u.Unit(unit)
+                except KeyError:
+                    return array
+                    
+            class_name = str(f['_class_name'])
+            array = _load_quantity('array')
+            cls = Container[array.unit, class_name]
+            return cls(data=array,
+                       **{name:_load_quantity(name) for name in ['time','energy','flavor']},
+                       integrable_axes=f['_integrable_axes'])
+            
+    def __eq__(self, other:'Container')->bool:
+        "Check if two Containers are equal"
+        result = self.__class__==other.__class__ and \
+                 self.unit == other.unit and \
+                 np.allclose(self.array, other.array) and \
+                 all([np.allclose(self.axes[ax], other.axes[ax]) for ax in Axes])
+        return result
+
+class Container(_ContainerBase):
+    #a dictionary holding classes for each unit
+    _unit_classes = {}
+
+    @wraps(_ContainerBase.__init__)
+    def __new__(cls, data,*args, **kwargs):
+        if not cls.unit:
+            data = u.Quantity(data)
+            cls = cls[data.unit]
+        return super().__new__(cls)
+
+    def __class_getitem__(cls, args):
+        try:
+            unit,name = args
+        except:
+            unit,name = args, None
+        #convert units to astropy.Unit
+        unit = u.Unit(unit)
+        if unit not in cls._unit_classes:
+            #create subclass of this type with given unit
+            name = name or f'{cls.__name__}[{unit}]'
+            cls._unit_classes[unit] = type(name,(cls,),{'unit':unit})
+        return cls._unit_classes[unit]
+        
+
+#some standard container classes that can be used for 
+Flux = Container['1/(MeV*s*cm**2)', "d2FdEdT"]
+Fluence = Container[Flux.unit*u.s, "dFdE"]
+Spectrum= Container[Flux.unit*u.MeV, "dFdT"]
+IntegralFlux= Container[Flux.unit*u.s*u.MeV, "dF"]
+
+DifferentialEventRate = Container['1/(MeV*s)', "d2NdEdT"]
+EventRate = Container['1/s', "dNdT"]
+EventSpectrum = Container['1/MeV', "dNdE"]
+EventNumber = Container['', "N"]
diff --git a/python/snewpy/models/base.py b/python/snewpy/models/base.py
index f762274..97f71f7 100644
--- a/python/snewpy/models/base.py
+++ b/python/snewpy/models/base.py
@@ -15,6 +15,7 @@ from snewpy.neutrino import Flavor
 from snewpy.flavor_transformation import NoTransformation
 from functools import wraps
 
+from snewpy.flux import Flux
 
 def _wrap_init(init, check):
     @wraps(init)
@@ -187,8 +188,10 @@ class SupernovaModel(ABC):
         """
         distance = distance << u.kpc #assume that provided distance is in kpc, or convert
         factor = 1/(4*np.pi*(distance.to('cm'))**2)
-        flux = self.get_transformed_spectra(t, E, flavor_xform)
-        return {flavor: f*factor for flavor,f in flux.items()}
+        f = self.get_transformed_spectra(t, E, flavor_xform)
+
+        array = np.stack([f[flv] for flv in sorted(Flavor)])
+        return  Flux(data=array*factor, flavor=np.sort(Flavor), time=t, energy=E)
 
 
 
diff --git a/python/snewpy/rate_calculator.py b/python/snewpy/rate_calculator.py
new file mode 100644
index 0000000..8bf26cd
--- /dev/null
+++ b/python/snewpy/rate_calculator.py
@@ -0,0 +1,173 @@
+"""
+The module :mod:`snewpy.rate_calculator` defines a Python interface for calculating event rates using data from SNOwGLoBES
+
+Reference
+---------
+.. autoclass:: RateCalculator
+    :members: run
+"""
+import numpy as np
+from snewpy.snowglobes_interface import SnowglobesData, guess_material
+from snewpy.neutrino import Flavor
+from snewpy.flux import Container
+from astropy import units as u
+from warnings import warn
+from typing import Dict
+
+#various utility methods
+def center(a):
+    return 0.5*(a[1:]+a[:-1])
+
+def _get_flavor_index(channel):
+    _map = {'+e':Flavor.NU_E,
+            '-e':Flavor.NU_E_BAR,
+            '+m':Flavor.NU_X,
+            '-m':Flavor.NU_X_BAR,
+            '+t':Flavor.NU_X,
+            '-t':Flavor.NU_X_BAR
+            }
+    return _map[channel.parity+channel.flavor]
+
+def _get_xsec_column(channel):
+    _map = {'+e':1, '+m':2, '+t':3, '-e':4, '-m':5, '-t':6 }
+    return _map[channel.parity+channel.flavor]
+    
+def _load_xsec(self, channel, energies):
+    """Load cross-section for a given channel, interpolated in the energies"""
+    xsec = np.loadtxt(self.base_dir/f"xscns/xs_{channel.name}.dat")
+    # Cross-section in 10^-38 cm^2
+    E = energies.to_value('GeV')
+    xp = xsec[:,0]
+    yp = xsec[:, _get_xsec_column(channel)]
+    xsecs = np.interp(np.log(E)/np.log(10), xp, yp, left=0, right=0)*E*1e-38 <<u.cm**2
+    return xsecs
+
+def _bin_edges_from_centers(centers:np.ndarray)->np.ndarray:
+    """calculate the bin edges based on the given central values"""
+    binw = np.diff(centers) #get the bin width
+    edges = centers-0.5*np.pad(binw,(0,1),mode='edge') #get lower edges
+    edges = np.append(edges,edges[-1]+binw[-1])
+    return edges
+#--------------------------------------
+class RateCalculator(SnowglobesData):
+    r"""Simple rate calculation interface.
+        Computes expected rate for a detector using SNOwGLoBES data. 
+       
+        Use :meth:`RateCalculator.run` method to run the simulation for specific detector and flux object.
+
+        Input flux can either be energy differential flux :math:`F_\nu(E_i) = \frac{d N}{d_E}(E_i)` or integral flux in the energy bins :math:`N_{\nu}(E_i)`.
+        
+        If the `detector_effects=False` the result is the number of neutrino interactions :math:`N` - a product with with cross-section :math:`\sigma(E)` and the number of targets in the detector :math:`N_{tgt}`:
+
+        .. math:: N (E_i) = N_{tgt} \cdot F_\nu(E_i)\cdot \sigma(E_i)
+
+
+        If the detector effects are included, it is integrated within the energy bins and multiplied by the smearing matrix and detection efficiency to get number of interactions in energy bin:
+
+        .. math:: 
+            
+            N_i = N_{tgt} \cdot \int\limits_{E_i}^{E_{i+1}}~F_\nu(E_i)~\sigma(E_i)~d E
+
+        and this is convoluted with the detector smearing matrix :math:`M_{ij}` and efficiency :math:`\varepsilon(E)`:
+
+        .. math::
+        
+            N^{rec}_i = \sum\limits_{j} M_{ij} \cdot N_j \cdot \varepsilon(E_i)
+        
+    """
+    def __init__(self, base_dir=''):
+        """
+        Parameters
+        ----------
+        base_dir:         Path or None
+            Path to the directory where the cross-section, detector, and channel files are located
+            If empty, try to get it from ``$SNOWGLOBES`` environment var
+        """
+        super().__init__(base_dir=base_dir)
+        
+    def _calc_rate(self, channel, TargetMass, flux):
+        """calculate interaction rate for given channel"""
+        flavor = _get_flavor_index(channel)
+        #check if we are provided with energy bins:
+        if not flux.can_integrate('energy'):
+            #we have bins, let's use central values for sampling
+            Evalues = center(flux.energy)
+        else:
+            #we have sample points, let's just use them
+            Evalues = flux.energy
+        xsec = _load_xsec(self, channel, Evalues)
+        Ntargets = TargetMass.to_value(u.Dalton)
+        rate = flux[flavor]*xsec*Ntargets
+        return rate
+    
+    def run(self, flux:Container, detector:str, material:str=None, detector_effects:bool = True)->Dict[str, Container]:
+        """Run the rate calculation for the given detector.    
+        
+        Parameters
+        ----------
+        flux: Container
+            The incoming neutrino flux (or fluence).
+        
+        detector: str
+            Name of the detector to calculate the rate. 
+            Check `RateCalculator.detectors` for the list of options
+        
+        material: str or None
+            Name of the detector material. 
+            Check `RateCalculator.materials` for the list of options
+            If `None` (default) it will be guessed based on the name of the detector
+
+        detector_effects: bool
+            If true (default), account for efficiency and smearing. If false, consider a perfect detector.
+
+        Returns
+        -------
+            dict[str, Container]
+                A dictionary with interaction rates (as instances of :class:`snewpy.flux.Container`) for each channel.
+        """
+        TargetMass = float(self.detectors[detector].tgt_mass)<<(1e3*u.tonne)
+        material = material or guess_material(detector)
+        binning = self.binning[material]
+        energies_t = binning['e_true']<<u.GeV
+        energies_s = binning['e_smear']<<u.GeV
+        smearing_shape = (len(energies_t), len(energies_s))
+        result = {}
+        for channel in self.channels[material].itertuples():
+            rate = self._calc_rate(channel, TargetMass, flux)
+            #apply channel weight 
+            rate = rate*channel.weight
+            #check the energy binning if needed
+            energy_bin_centers = center(rate.energy)
+            if detector_effects and not rate.can_integrate('energy'):
+                    if not np.allclose(energy_bin_centers<<u.GeV,energies_s<<u.GeV):
+                        raise ValueError(f'Fluence energy values should be equal to smearing matrix binning. Check binning["{material}"]["e_true"]!')
+            
+            if detector_effects:
+                if rate.can_integrate('energy'):
+                    #integrate over given energy bins
+                    energy_bins = _bin_edges_from_centers(energies_t)
+                    rateI = rate.integrate('energy', energy_bins)
+                else:
+                    rateI = rate
+                try:
+                    smear = self.smearings[detector][channel.name]
+                except KeyError:
+                    warn(f'Smearing not found for detector={detector}, channel={channel.name}. Using unsmeared spectrum')
+                    smear = np.eye(*smearing_shape)
+                try:
+                    effic = self.efficiencies[detector][channel.name]
+                except KeyError:
+                    warn(f'Efficiency not found for detector={detector}, channel={channel.name}. Using 100% efficiency')
+                    effic = np.ones(len(energies_s))
+                #apply smearing and efficiency
+                rateS_array = np.dot(rateI.array, smear.T) * effic
+                rateS = Container(rateS_array, 
+                                  flavor=rateI.flavor, 
+                                  time=rateI.time, 
+                                  energy=_bin_edges_from_centers(energies_s)<<u.MeV,
+                                  integrable_axes=rateI._integrable_axes)
+
+                result[channel.name] = rateS
+            else:
+                result[channel.name] = rate
+        return result
diff --git a/python/snewpy/snowglobes.py b/python/snewpy/snowglobes.py
index e70db70..53e78cd 100644
--- a/python/snewpy/snowglobes.py
+++ b/python/snewpy/snowglobes.py
@@ -19,7 +19,6 @@ There are three basic steps to using SNOwGLoBES from SNEWPY:
     The output tables allow to build the detected neutrino energy spectrum and neutrino time distribution, for each reaction channel or the sum of them.
 """
 
-import io
 import logging
 import os
 import re
@@ -29,15 +28,15 @@ from tempfile import TemporaryDirectory
 
 import matplotlib.pyplot as plt
 import numpy as np
+import pandas as pd
 from astropy import units as u
-from tqdm.auto import tqdm
 from warnings import warn
 
 import snewpy.models
 from snewpy.flavor_transformation import *
-from snewpy.neutrino import Flavor, MassHierarchy
-from snewpy.snowglobes_interface import SimpleRate
-
+from snewpy.neutrino import MassHierarchy
+from snewpy.rate_calculator import RateCalculator, center
+from snewpy.flux import Container
 logger = logging.getLogger(__name__)
 
 def generate_time_series(model_path, model_type, transformation_type, d, output_filename=None, ntbins=30, deltat=None, snmodel_dict={}):
@@ -68,7 +67,7 @@ def generate_time_series(model_path, model_type, transformation_type, d, output_
     Returns
     -------
     str
-        Path of compressed .tar file with neutrino flux data.
+        Path of NumPy archive file with neutrino fluence data.
     """
     model_class = getattr(snewpy.models.ccsn, model_type)
 
@@ -88,63 +87,18 @@ def generate_time_series(model_path, model_type, transformation_type, d, output_
     else:
         dt = (tmax - tmin) / (ntbins+1)
 
-    tedges = np.arange(tmin/u.s, tmax/u.s, dt/u.s)*u.s
-    times = 0.5*(tedges[1:] + tedges[:-1])
-
-    # Generate output.
+    times = np.arange(tmin/u.s, tmax/u.s, dt/u.s)*u.s
+    energy = np.linspace(0, 100, 501) * u.MeV
+    flux = snmodel.get_flux(t=times, E=energy,  distance=d, flavor_xform=flavor_transformation)
+    fluence = flux.integrate('time', limits = times).integrate('energy', limits = energy)
+    #save resulting fluence to file
     if output_filename is not None:
-        tfname = output_filename + 'kpc.tar.bz2'
+        tfname = output_filename + '.npz'
     else:
         model_file_root, _ = os.path.splitext(model_file)  # strip extension (if present)
-        tfname = model_file_root + '.' + transformation_type + '.{:.3f},{:.3f},{:d}-{:.1f}'.format(tmin, tmax, ntbins, d) + 'kpc.tar.bz2'
-
-    with tarfile.open(os.path.join(model_dir, tfname), 'w:bz2') as tf:
-        #creates file in tar archive that gives information on parameters
-        output = '\n'.join(map(str, transformation_type)).encode('ascii')
-        tf.addfile(tarfile.TarInfo(name='parameterinfo'), io.BytesIO(output))
-
-        MeV = 1.60218e-6 * u.erg
-        energy = np.linspace(0, 100, 501) * MeV  # 1MeV
-
-        # Loop over sampled times.
-        for i, t in enumerate(times):
-            osc_spectra = snmodel.get_transformed_spectra(t, energy, flavor_transformation)
-
-            osc_fluence = {}
-            table = []
-
-            table.append('# TBinMid={:g}sec TBinWidth={:g}s EBinWidth=0.2MeV Fluence at Earth for this timebin in neutrinos per cm^2'.format(t, dt))
-            table.append('# E(GeV)	NuE	NuMu	NuTau	aNuE	aNuMu	aNuTau')
-
-            # Generate energy + number flux table.
-            for j, E in enumerate(energy):
-                for flavor in Flavor:
-                    osc_fluence[flavor] = osc_spectra[flavor][j] * dt * 0.2 * MeV / (4.*np.pi*(d*1000*3.086e+18)**2)
-
-                s = '{:17.8E}'.format(E/(1e3 * MeV))
-                s = '{}{:17.8E}'.format(s, osc_fluence[Flavor.NU_E])
-                s = '{}{:17.8E}'.format(s, osc_fluence[Flavor.NU_X])
-                s = '{}{:17.8E}'.format(s, osc_fluence[Flavor.NU_X])
-                s = '{}{:17.8E}'.format(s, osc_fluence[Flavor.NU_E_BAR])
-                s = '{}{:17.8E}'.format(s, osc_fluence[Flavor.NU_X_BAR])
-                s = '{}{:17.8E}'.format(s, osc_fluence[Flavor.NU_X_BAR])
-                table.append(s)
-                logging.debug(s)
-
-            # Encode energy/flux table and output to file in tar archive.
-            output = '\n'.join(table).encode('ascii')
-
-            extension = ".dat"
-            model_file_root, _ = os.path.splitext(model_file)
-            filename = model_file_root + '.tbin{:01d}.'.format(i+1) + transformation_type + \
-                '.{:.3f},{:.3f},{:01d}-{:.1f}kpc{}'.format(tmin/u.s, tmax/u.s, ntbins, d, extension)
-
-            info = tarfile.TarInfo(name=filename)
-            info.size = len(output)
-            tf.addfile(info, io.BytesIO(output))
-
-    return os.path.join(model_dir, tfname)
-
+        tfname = f'{model_file_root}.{transformation_type}.{tmin:.3f},{tmax:.3f},{ntbins:d}-{d:.1f}.npz'
+    fluence.save(tfname)
+    return tfname
 
 def generate_fluence(model_path, model_type, transformation_type, d, output_filename=None, tstart=None, tend=None, snmodel_dict={}):
     """Generate fluence files in SNOwGLoBES format.
@@ -174,7 +128,7 @@ def generate_fluence(model_path, model_type, transformation_type, d, output_file
     Returns
     -------
     str
-        Path of compressed .tar file with neutrino flux data.
+        Path of NumPy archive file with neutrino fluence data.
     """
     model_class = getattr(snewpy.models.ccsn, model_type)
 
@@ -187,133 +141,34 @@ def generate_fluence(model_path, model_type, transformation_type, d, output_file
 
     #set the timings up
     #default if inputs are None: full time window of the model
-    if tstart is None:
-        tstart = snmodel.get_time()[0]
-        tend = snmodel.get_time()[-1]
-
-    try:
-        if len(tstart/u.s) > 0:
-            t0 = tstart[0]
-            t1 = tend[-1]
-            nbin = len(tstart/u.s)
-    except:
-        t0 = tstart
-        t1 = tend
-        nbin = 1
-
-    times = 0.5*(tstart + tend)
-
-    model_times = snmodel.get_time()
-    model_tstart = model_times*1.0
-    model_tend = model_times*1.0
-
-    model_tstart[0] = model_times[0]
-    for i in range(1, len(model_times)):
-        model_tstart[i] = 0.5*(model_times[i]+model_times[i-1])
-        model_tend[i-1] = model_tstart[i]
-    model_tend[len(model_times)-1] = model_times[-1]
-
-    if nbin > 1:
-        starting_index = np.zeros(len(times), dtype=np.int64)
-        ending_index = np.zeros(len(times), dtype=np.int64)
-        for i in range(len(tstart)):
-            starting_index[i] = next(j for j, t in enumerate(model_tend) if t > tstart[i])
-            ending_index[i] = next(j for j, t in enumerate(model_tend) if t >= tend[i])
-    else:
-        starting_index = [next(j for j, t in enumerate(model_tend) if t > tstart)]
-        ending_index = [next(j for j, t in enumerate(model_tend) if t >= tend)]
-
-    # Generate output.
+    times = None
+    if tstart is not None and tend is not None:
+        try:
+            #in case we have arrays: join them together
+            times = np.append(tstart, tend)
+            #and get rid of the duplicates with 1e-10 tolerance
+            times = np.unique(times.round(decimals=10))
+        except:
+            #in case we have single values
+            times = u.Quantity([tstart,tend])
+        times.sort()
+
+    #energy with 0.2 MeV binning
+    energy   = np.arange(0, 101, 0.2) << u.MeV
+    #energy bins similar to SNOwGLoBES
+    energy_t = (np.linspace(0, 100, 201)+0.25) << u.MeV 
+    flux = snmodel.get_flux(t=snmodel.get_time(), E=energy,  distance=d, flavor_xform=flavor_transformation)
+    fluence = flux.integrate('time', limits = times).integrate('energy', limits = energy_t)
+    times = fluence.time
+    #store the energy bin centers instead of the edges
     if output_filename is not None:
-        tfname = output_filename+'.tar.bz2'
+        tfname = output_filename+'.npz'
     else:
         model_file_root, _ = os.path.splitext(model_file)  # strip extension (if present)
-        tfname = model_file_root + '.' + transformation_type + '.{:.3f},{:.3f},{:d}-{:.1f}'.format(t0, t1, nbin, d) + 'kpc.tar.bz2'
-
-    with tarfile.open(os.path.join(model_dir, tfname), 'w:bz2') as tf:
-        #creates file in tar archive that gives information on parameters
-        output = '\n'.join(map(str, transformation_type)).encode('ascii')
-        tf.addfile(tarfile.TarInfo(name='parameterinfo'), io.BytesIO(output))
-
-        MeV = 1.60218e-6 * u.erg
-        energy = np.linspace(0, 100, 501) * MeV
-
-        # Loop over sampled times.
-        for i in range(nbin):
-
-            if nbin > 1:
-                ta = tstart[i]
-                tb = tend[i]
-                t = times[i]
-                dt = tb-ta
-            else:
-                ta = tstart
-                tb = tend
-                t = times
-                dt = tb-ta
-
-            #first time bin of model in requested interval
-            osc_spectra = snmodel.get_transformed_spectra(model_times[starting_index[i]], energy, flavor_transformation)
-
-            if dt >= model_tend[starting_index[i]]-ta:
-                for flavor in Flavor:
-                    osc_spectra[flavor] *= (model_tend[starting_index[i]]-ta)
-
-                #intermediate time bins of model in requested interval
-                for j in range(starting_index[i]+1, ending_index[i]):
-                    temp_spectra = snmodel.get_transformed_spectra(model_times[j], energy, flavor_transformation)
-                    for flavor in Flavor:
-                        osc_spectra[flavor] += temp_spectra[flavor]*(model_tend[j]-model_tstart[j])
-
-                #last time bin of model in requested interval
-                temp_spectra = snmodel.get_transformed_spectra(
-                    model_times[ending_index[i]], energy, flavor_transformation)
-                for flavor in Flavor:
-                    osc_spectra[flavor] += temp_spectra[flavor]*(tb-model_tstart[ending_index[i]])
-
-                for flavor in Flavor:
-                    osc_spectra[flavor] /= (tb-ta)
-
-            osc_fluence = {}
-            table = []
-
-            table.append('# TBinMid={:g}sec TBinWidth={:g}s EBinWidth=0.2MeV Fluence at Earth for this timebin in neutrinos per cm^2'.format(t, dt))
-            table.append('# E(GeV)	NuE	NuMu	NuTau	aNuE	aNuMu	aNuTau')
-
-            # Generate energy + number flux table.
-            for j, E in enumerate(energy):
-                for flavor in Flavor:
-                    osc_fluence[flavor] = osc_spectra[flavor][j] * dt * 0.2 * MeV / (4.*np.pi*(d*1000*3.086e+18)**2)
-
-                s = '{:17.8E}'.format(E/(1e3 * MeV))
-                s = '{}{:17.8E}'.format(s, osc_fluence[Flavor.NU_E])
-                s = '{}{:17.8E}'.format(s, osc_fluence[Flavor.NU_X])
-                s = '{}{:17.8E}'.format(s, osc_fluence[Flavor.NU_X])
-                s = '{}{:17.8E}'.format(s, osc_fluence[Flavor.NU_E_BAR])
-                s = '{}{:17.8E}'.format(s, osc_fluence[Flavor.NU_X_BAR])
-                s = '{}{:17.8E}'.format(s, osc_fluence[Flavor.NU_X_BAR])
-                table.append(s)
-                logging.debug(s)
-
-            # Encode energy/flux table and output to file in tar archive.
-            output = '\n'.join(table).encode('ascii')
-
-            extension = ".dat"
-            if output_filename is not None:
-                if nbin > 1:
-                    filename = output_filename+"_"+str(i)+extension
-                else:
-                    filename = output_filename+extension
-            else:
-                model_file_root, _ = os.path.splitext(model_file)  # strip extension (if present)
-                filename = model_file_root + '.tbin{:01d}.'.format(i+1) + transformation_type + \
-                    '.{:.3f},{:.3f},{:01d}-{:.1f}kpc{}'.format(t0, t1, nbin, d, extension)
-
-            info = tarfile.TarInfo(name=filename)
-            info.size = len(output)
-            tf.addfile(info, io.BytesIO(output))
+        tfname = f'{model_file_root}.{transformation_type}.{times[0]:.3f},{times[1]:.3f},{len(times)-1:d}-{d:.1f}.npz'
 
-    return os.path.join(model_dir, tfname)
+    fluence.save(tfname)
+    return tfname
 
 def simulate(SNOwGLoBESdir, tarball_path, detector_input="all", verbose=False, *, detector_effects=True):
     """Calculate expected event rates for the given neutrino flux files and the given (set of) SNOwGLoBES detector(s).
@@ -335,27 +190,56 @@ def simulate(SNOwGLoBESdir, tarball_path, detector_input="all", verbose=False, *
     if verbose:  # Deprecated since SNEWPY v1.2
         warn(f"The 'verbose' parameter to 'snewpy.snowglobes.simulate()' is deprecated and should not be used.", FutureWarning)
 
-    sng = SimpleRate(base_dir=SNOwGLoBESdir, detectors=detector_input, detector_effects=detector_effects)
-    detector_input = list(sng.detectors)
-
+    rc = RateCalculator(base_dir=SNOwGLoBESdir)
+    if detector_input == 'all':
+        detector_input = list(rc.detectors)
+    if(isinstance(detector_input,str)):
+        detector_input=[detector_input]
+    rates_dict = {}
+    #read the fluence
+    fluence = Container.load(tarball_path)
+    for det in detector_input:
+        rates_smeared=rc.run(fluence, det, detector_effects=True)
+        rates_unsmeared=rc.run(fluence, det, detector_effects=False)
+        #collect everything to pandas DataFrame, to make the output similar to previous
+        rates_dict[det]={'weighted':{'unsmeared':rates_unsmeared,
+                                 'smeared':rates_smeared,
+                                }}
+    # reorder results to produce the same format as before:
+    #    {detector: {time_bin:{'weighted':{smeared/unsmeared: [rate vs energy bins]}}}}
     result = {}
-    #Extracts data from tarfile and sets up lists of paths and fluxfilenames for later use
-    with TemporaryDirectory(prefix='snowglobes') as tempdir:
-        with tarfile.open(tarball_path) as tar:
-            tar.extractall(tempdir)
-
-        flux_files = list(Path(tempdir).glob('*.dat'))
-        if len(detector_input)>0:
-            detector_input = tqdm(detector_input, desc='Detectors', leave=False)
-        for det in detector_input:
-            res=sng.run(flux_files, det)
-            result[det]=dict(zip((f.stem for f in flux_files),res))
-
+    fname_base = tarball_path[:tarball_path.rfind('.')]
+    for det in rates_dict:
+        #get the time bins
+        rates_smeared   = rates_dict[det]['weighted']['smeared']
+        rates_unsmeared = rates_dict[det]['weighted']['unsmeared']
+
+        #get the first rate from the dict to access the energy and time binning
+        some_rate = list(rates_smeared.values())[0]
+        tbins = center(some_rate.time)
+        ebins = center(some_rate.energy)
+        result[det] = {}
+        for n_bin, t_bin in enumerate(tbins):
+            data = {**{(chan,'unsmeared','weighted'): rate.array[0,n_bin,:]
+                      for chan,rate in rates_unsmeared.items()},
+                    **{(chan,'smeared','weighted'): rate.array[0,n_bin,:] 
+                      for chan,rate in rates_smeared.items()}}
+            
+            df = pd.DataFrame(data, index = ebins)
+            df.index.rename('E', inplace=True)
+            df.columns.rename(['channel','is_smeared','is_weighted'], inplace=True)
+            df = df.reorder_levels([2,1,0], axis='columns')
+            if len(tbins) > 1:
+                result[det][f'{fname_base}_{n_bin:01d}'] = df
+            else:
+                result[det][f'{fname_base}'] = df
+        
     # save result to file for re-use in collate()
-    cache_file = tarball_path[:tarball_path.rfind('.tar')] + '.npy'
+    cache_file = f'{fname_base}.npy'
     logging.info(f'Saving simulation results to {cache_file}')
     np.save(cache_file, result)
-    return result 
+    return result
+
 
 re_chan_label = re.compile(r'nu(e|mu|tau)(bar|)_([A-Z][a-z]*)(\d*)_?(.*)')
 def get_channel_label(c):
@@ -446,7 +330,7 @@ def collate(SNOwGLoBESdir, tarball_path, detector_input="", skip_plots=False, ve
             plt.ylabel('Interaction Events')  
 
     #read the results from storage
-    cache_file = tarball_path[:tarball_path.rfind('.tar')] + '.npy'
+    cache_file = tarball_path[:tarball_path.rfind('.')] + '.npy'
     logging.info(f'Reading tables from {cache_file}')
     tables = np.load(cache_file, allow_pickle=True).tolist()
     #This output is similar to what produced by:
@@ -462,7 +346,7 @@ def collate(SNOwGLoBESdir, tarball_path, detector_input="", skip_plots=False, ve
             results[det] = {}
             for flux,t in tables[det].items():
                 t = aggregate_channels(t,nc='nc_',e='_e')
-                for w in ['weighted','unweighted']:
+                for w in ['weighted']:
                     for s in smearing_options:
                         table = t[w][s]
                         filename_base = f'{flux}_{det}_events_{s}_{w}'
diff --git a/python/snewpy/snowglobes_interface.py b/python/snewpy/snowglobes_interface.py
index e39cc1f..7f194c5 100644
--- a/python/snewpy/snowglobes_interface.py
+++ b/python/snewpy/snowglobes_interface.py
@@ -43,17 +43,10 @@ def guess_material(detector):
         mat = mat+'_he'
     return mat
 
-
-class SimpleRate():
-    def __init__(self, detectors:str="all", detector_effects=True, base_dir:Path=''):
-        """Simple rate calculation interface.
-        Computes expected rate for a detector without using GLOBES. The formula for the rate is
-
-                Rate = Sum_i ([cross-section in 10^-38 cm^2] x 10^-38 x [fluence in cm^-2])_i x [smearing matrix]_{ij}
-                       x [target mass in kton] x [Dalton per kton] x [energy bin size in GeV] x [efficiency]
-
-        with [target mass in kton] x [Dalton per kton] = number of reference targets in experiment.
-
+class SnowglobesData:
+    def __init__(self, base_dir:Path='', detectors:str="all", detector_effects=True):
+        """Interface to SNOwGLoBES data
+        
         On construction the code will read: 
 
         * detectors from `<base_dir>/detector_configurations.dat`,
@@ -64,19 +57,17 @@ class SimpleRate():
         * efficiencies from `<base_dir>/effic/effic_*.dat`,
         * smearing matrices from `<base_dir>/smear/smear_*.dat`
 
-        After that use :meth:`SimpleRate.run` method to run the simulation for specific detector and flux file.
-
         Parameters
         ----------
+        base_dir:         Path or None
+            Path to the directory where the cross-section, detector, and channel files are located
+            If empty, try to get it from ``$SNOWGLOBES`` environment var
+            
         detectors: str
             Name of detector. If ``"all"``, will use all detectors supported by SNOwGLoBES.
 
         detector_effects: bool
             If true, account for efficiency and smearing. If false, consider a perfect detector.
-
-        base_dir:         Path or None
-            Path to the directory where the cross-section, detector, and channel files are located.
-            If empty, try to get it from ``$SNOWGLOBES`` environment var or the `snowglobes_data` module.
         """
         try:
             self.base_dir = Path(base_dir if base_dir else os.environ['SNOWGLOBES'])
@@ -132,8 +123,8 @@ class SimpleRate():
             self.channels[material] = df
 
             nsamples, smin, smax, nbins, emin, emax = [float(t) for t in tokens]
-            self.binning[material] = {'e_true': np.linspace(smin, smax, int(nsamples)+1),
-                                      'e_smear': np.linspace(emin, emax, int(nbins)+1)
+            self.binning[material] = {'e_true': np.linspace(smin, smax, int(nsamples)),
+                                      'e_smear': np.linspace(emin, emax, int(nbins))
                                       }
         self.materials = list(self.channels.keys())
         self.chan_dir = chan_dir
@@ -175,6 +166,32 @@ class SimpleRate():
         logger.info(f'read smearing matrices for detectors: {list(self.smearings.keys())}')
         logger.debug(f'smearing matrices: {self.smearings}')
 
+class SimpleRate(SnowglobesData):
+    def __init__(self, detectors:str="all", detector_effects=True, base_dir:Path=''):
+        """Simple rate calculation interface.
+        Computes expected rate for a detector without using GLOBES. The formula for the rate is
+
+                Rate = Sum_i ([cross-section in 10^-38 cm^2] x 10^-38 x [fluence in cm^-2])_i x [smearing matrix]_{ij}
+                       x [target mass in kton] x [Dalton per kton] x [energy bin size in GeV] x [efficiency]
+
+        with [target mass in kton] x [Dalton per kton] = number of reference targets in experiment.
+
+        Use :meth:`SimpleRate.run` method to run the simulation for specific detector and flux file.
+
+        Parameters
+        ----------
+        detectors: str
+            Name of detector. If ``"all"``, will use all detectors supported by SNOwGLoBES.
+
+        detector_effects: bool
+            If true, account for efficiency and smearing. If false, consider a perfect detector.
+
+        base_dir:         Path or None
+            Path to the directory where the cross-section, detector, and channel files are located
+            If empty, try to get it from ``$SNOWGLOBES`` environment var
+        """    
+        super().__init__(base_dir, detectors=detectors, detector_effects = detector_effects)
+        
     def compute_rates(self, detector:str, material:str, fluxes:np.ndarray, flux_energies:np.ndarray):
         """ Calculate the rates for the given neutrino fluxes interacting in the given detector.
 
@@ -206,7 +223,7 @@ class SimpleRate():
         #load the binning for the smearing
         binning= self.binning[material]
         #calculate bin centers 
-        energies_t = 0.5*(binning['e_true'][1:]+ binning['e_true'][:-1] )
+        energies_t = 0.5*(binning['e_true'][1:]+ binning['e_true'][:-1])
         energies_s= 0.5*(binning['e_smear'][1:]+binning['e_smear'][:-1])
         binsize = np.diff(binning['e_true'])
 
diff --git a/setup.py b/setup.py
index 522298a..c829cbf 100644
--- a/setup.py
+++ b/setup.py
@@ -51,7 +51,7 @@ with open('requirements.txt', 'r') as f:
             requires.append(line.strip())
 setup_keywords['install_requires'] = requires
 setup_keywords['extras_require'] = {  # Optional
-    'dev': ['pytest'],
+    'dev': ['pytest','hypothesis'],
     'docs':['numpydoc']
 }
 #


Test patch:
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index d20ac00..487389f 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -34,11 +34,9 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install pytest
-          if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
       - name: Install SNEWPY
         run: |
-          python setup.py install --user
+          pip install ".[dev]"
       
       # Run the unit tests
       - name: Test with pytest
diff --git a/python/snewpy/test/simplerate_integrationtest.py b/python/snewpy/test/simplerate_integrationtest.py
index 2140138..950f3ed 100644
--- a/python/snewpy/test/simplerate_integrationtest.py
+++ b/python/snewpy/test/simplerate_integrationtest.py
@@ -63,8 +63,8 @@ class TestSimpleRate(unittest.TestCase):
 
         # We do not use the SNOwGLoBES scaling factors but use other constants so we do not
         # expect the results to agree to 7 digits. Here sub-permille agreement is good enough.
-        sk_expected = 4486.929197175579
-        sk_expected_smeared = 4044.841743901513
+        sk_expected = 4491.783259
+        sk_expected_smeared = 4065.662374
         sk_computed = 0.32 * total_events
         sk_computed_smeared = 0.32 * total_events_smeared
         discrepancy = abs(sk_computed - sk_expected)/sk_expected
diff --git a/python/snewpy/test/test_flux_container.py b/python/snewpy/test/test_flux_container.py
new file mode 100644
index 0000000..6f5b9fc
--- /dev/null
+++ b/python/snewpy/test/test_flux_container.py
@@ -0,0 +1,111 @@
+from hypothesis import given, assume, note
+from hypothesis import strategies as st
+from hypothesis.extra.numpy import arrays, array_shapes
+
+from snewpy.flux import Container,Axes
+from snewpy.neutrino import Flavor
+import numpy as np
+import astropy.units as u
+import pytest
+#define strategies to generate float values
+def float_values(shape=array_shapes(max_dims=1),**kwargs):
+    return arrays(float, shape=shape, 
+                  elements={'allow_nan':False, 
+                            'allow_infinity':False,
+                            'min_value':-1e100,
+                            'max_value':1e100
+                           },
+                  **kwargs)
+
+def sorted_floats(shape=array_shapes(max_dims=1)):
+    return float_values(shape, unique=True).map(np.sort)
+
+def to_unit(unit):
+    def _f(values):
+        return values<<u.Unit(unit)
+
+@st.composite
+def quantities(draw, values, unit):
+    return draw(values)<<unit
+
+#how to generate axes values
+flavors = st.lists(elements=st.sampled_from(Flavor),
+                   unique=True,min_size=1,max_size=len(Flavor)).map(sorted)
+units = st.sampled_from(['1/MeV','1/(MeV*s)','1/(MeV*s*cm**2)']).map(u.Unit)
+energies = quantities(sorted_floats(shape=array_shapes(max_dims=1)),u.MeV)
+times    = quantities(sorted_floats(shape=array_shapes(max_dims=1)),u.s)
+integrable_axess = st.lists(st.sampled_from(list(Axes)[1:]))
+
+@st.composite
+def random_flux_containers(draw, times=times, energies=energies, units=units, axes=st.just(None)):
+    "Strategy to generate a random flux container"
+    T,E = draw(times),draw(energies)
+    flavor = draw(flavors)
+    unit = draw(units)
+    
+    shape=[len(flavor),len(T),len(E)]
+    array_data = quantities(float_values(shape),unit)
+    array = draw(array_data)
+    return Container[unit](array,flavor,T,E, integrable_axes=draw(axes))
+
+#remove infinities and NaNs for the floats generation
+st.register_type_strategy(float, st.floats(allow_nan=False, allow_infinity=False))
+
+#starting test sets
+#--------------------------------------------------------------
+@given(flavor=flavors, time=times, energy=energies, unit=units)
+def test_construction_succesfull(flavor, energy, time, unit):
+    data = np.ones([len(flavor),len(time), len(energy)])<<unit
+    assert Container[unit](data, flavor, time, energy)
+
+@given(flavor=flavors, time=times, energy=energies, unit=units)
+def test_construction_with_wrong_units_raises_ValueError(flavor, energy, time, unit):
+    data = np.ones([len(flavor),len(time), len(energy)])<<unit
+    with pytest.raises(u.UnitConversionError):
+        Container[unit*u.kg](data, flavor, time, energy)
+    with pytest.raises(u.UnitConversionError):
+        Container[unit](data*u.kg, flavor, time, energy)
+
+@given(f=random_flux_containers())
+def test_summation_over_flavor(f:Container):
+    fS = f.sum('flavor')
+    #check the result array shapes
+    assert fS.shape[Axes.flavor] == 1
+    assert fS.shape[Axes.energy] == f.shape[Axes.energy]
+    assert fS.shape[Axes.time]   == f.shape[Axes.time]
+    #check the resulting array values
+    assert np.allclose(fS.array, f.array.sum(axis=Axes.flavor))
+
+axess_not_flavor = st.sampled_from([Axes.time,Axes.energy])
+
+@given(f=random_flux_containers(), axis=axess_not_flavor
+      )
+def test_summation_over_wrong_axis_raises_ValueError(f:Container, axis:str):
+    with pytest.raises(ValueError):
+        fS = f.sum(axis)
+    
+@given(f=random_flux_containers())
+def test_integration_over_flavor_raises_ValueError(f:Container):
+    with pytest.raises(ValueError):
+        fS = f.integrate('flavor')
+    
+@given(f=random_flux_containers(), axis=axess_not_flavor)
+def test_integration_over_axes(f:Container, axis):
+    #we don't want to integrate over single value
+    assume(f.shape[axis]>1)
+    note(f'Array is {str(f.array)}')
+    fI = f.integrate(axis)
+    for a in Axes:
+        if a!=axis:
+            assert fI.shape[a] == f.shape[a]
+        else:
+            assert fI.shape[a] == 1
+    #check the resulting array values
+    assert fI.unit == f.unit*f.axes[axis].unit
+
+@given(f=random_flux_containers())
+def test_save_and_load(f):
+    fname = '/tmp/flux.npz'
+    f.save(fname)
+    f1 = Container.load(fname)
+    assert f1==f
\ No newline at end of file
diff --git a/python/snewpy/test/test_rate_calculation.py b/python/snewpy/test/test_rate_calculation.py
new file mode 100644
index 0000000..aed3f23
--- /dev/null
+++ b/python/snewpy/test/test_rate_calculation.py
@@ -0,0 +1,62 @@
+import numpy as np
+import astropy.units as u
+import pytest
+from snewpy.models import ccsn
+from snewpy.rate_calculator import RateCalculator
+
+from snewpy import flavor_transformation as ft
+pytestmark=pytest.mark.snowglobes
+
+#numbers from SNEWSv2 paper - for approximate checks 
+crosscheck_table=[  ('icecube',          320e3),
+                    ('wc100kt30prct',4044.8/0.32),
+                    ('ar40kt',              2700),
+                    ('novaND',                40),
+                    ('novaFD',              1900),
+                    ('halo1',                  4),
+                    ('halo2',                 53)]
+
+#numbers from the SNEWPY SNOwGLoBES interface - for approximate checks 
+#of simple rate computation (no smearing)
+crosscheck_table_unsmeared=[  ('icecube',          7.2352e6),
+                    ('wc100kt30prct',4486.9/0.32),
+                    ('ar40kt',              2858.7),
+                    ('novaND',                41.7231),
+                    ('novaFD',              1947.0768),
+                    ('halo1',                  11.5709),
+                    ('halo2',                 146.4671)]
+
+@pytest.fixture(autouse=True)
+def snmodel():
+    return ccsn.Bollig_2016(progenitor_mass=11.2<<u.Msun)
+
+@pytest.fixture(autouse=True)
+def rc():
+    return RateCalculator()
+    
+@pytest.fixture
+def fluence(snmodel):
+    times    = snmodel.get_time()
+    energies = np.linspace(0.5,100,201)<<u.MeV
+    #get the flux from the model
+    flux = snmodel.get_flux(t=times, E=energies, distance=10<<u.kpc, flavor_xform=ft.AdiabaticMSW())
+    return flux.integrate('time')
+
+@pytest.mark.parametrize('detector, expected_total',crosscheck_table_unsmeared)
+def test_rate_unsmeared(rc, fluence, detector, expected_total):    
+    #calculate the event rates
+    rates = rc.run(fluence, detector, detector_effects=False)
+    #calculate the total IBD event rate 
+    N_total = sum([r.integrate_or_sum('energy').array.value for r in rates.values()])
+    print(N_total)
+    #check the final value
+    assert N_total == pytest.approx(expected_total, 0.01)
+    
+@pytest.mark.parametrize('detector, expected_total',crosscheck_table)
+def test_rate_smeared(rc, fluence, detector, expected_total):
+    #calculate the event rates
+    rates = rc.run(fluence, detector, detector_effects=True)
+    #calculate the total IBD event rate 
+    N_total = sum([r.integrate_or_sum('energy').array.value for r in rates.values()])
+    #check the final value
+    assert N_total == pytest.approx(expected_total, 0.1)