diff --git a/external/TimeSeries b/external/TimeSeries
index 22e3e45..1c245f8 160000
--- a/external/TimeSeries
+++ b/external/TimeSeries
@@ -1 +1 @@
-Subproject commit 22e3e4553178230053aac40131b4fdb36c163075
+Subproject commit 1c245f84d0728d99b6f5deab7793fb238105a54d
diff --git a/include/Data/SpectrogramTimeSerie.h b/include/Data/SpectrogramTimeSerie.h
index b453f06..c2d2d2b 100644
--- a/include/Data/SpectrogramTimeSerie.h
+++ b/include/Data/SpectrogramTimeSerie.h
@@ -4,11 +4,14 @@
 #include "CoreGlobal.h"
 
 #include <TimeSeries.h>
+#include <cmath>
 
 class SCIQLOP_CORE_EXPORT SpectrogramTimeSerie
     : public TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>
 {
 public:
+  double min_sampling = std::nan("");
+  double max_sampling = std::nan("");
   using item_t =
       decltype(std::declval<
                TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>>()[0]);
@@ -22,8 +25,11 @@ public:
                        SpectrogramTimeSerie::axis_t&& y,
                        SpectrogramTimeSerie::container_type<
                            SpectrogramTimeSerie::raw_value_type>&& values,
-                       std::vector<std::size_t>& shape)
-      : TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>(t, values, shape)
+                       std::vector<std::size_t>& shape, double min_sampling,
+                       double max_sampling)
+      : TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>(t, values,
+                                                               shape),
+        min_sampling{min_sampling}, max_sampling{max_sampling}
   {
     _axes[1] = y;
   }
diff --git a/include/Data/TimeSeriesUtils.h b/include/Data/TimeSeriesUtils.h
index daeda64..e4b69dc 100644
--- a/include/Data/TimeSeriesUtils.h
+++ b/include/Data/TimeSeriesUtils.h
@@ -43,6 +43,8 @@ namespace TimeSeriesUtils
     double range;
     double max_resolution;
     bool is_log;
+    double min;
+    double max;
   };
 
   constexpr auto IsLog    = true;
@@ -54,7 +56,8 @@ namespace TimeSeriesUtils
   template<bool is_log, bool check_median>
   axis_properties axis_analysis(
       typename std::conditional<is_log, std::vector<double>&,
-                                const std::vector<double>&>::type axis)
+                                const std::vector<double>&>::type axis,
+      double given_max_resolution = std::nan(""))
   {
     std::vector<double> axis_diff(axis.size());
     if constexpr(is_log)
@@ -62,20 +65,27 @@ namespace TimeSeriesUtils
       std::transform(std::cbegin(axis), std::cend(axis), std::begin(axis),
                      [](const auto v) { return std::log10(v); });
     }
-    auto range = *(std::cend(axis) - 1) - *(std::begin(axis));
-    std::adjacent_difference(std::cbegin(axis), std::cend(axis),
-                             std::begin(axis_diff));
-    auto min_diff =
-        (*std::min_element(std::cbegin(axis_diff) + 1, std::cend(axis_diff)));
-    if constexpr(check_median)
+    auto min      = *std::begin(axis);
+    auto max      = *(std::cend(axis) - 1);
+    auto range    = max - min;
+    auto min_diff = given_max_resolution;
+    if(std::isnan(min_diff))
     {
-      std::nth_element(std::begin(axis_diff) + 1,
-                       std::begin(axis_diff) + axis_diff.size() / 2,
-                       std::end(axis_diff));
-      auto median_diff = *(std::begin(axis_diff) + axis_diff.size() / 2);
-      if(median_diff > (4 * min_diff)) min_diff = median_diff;
+      std::adjacent_difference(std::cbegin(axis), std::cend(axis),
+                               std::begin(axis_diff));
+      min_diff =
+          (*std::min_element(std::cbegin(axis_diff) + 1, std::cend(axis_diff)));
+      if constexpr(check_median)
+      {
+        std::nth_element(std::begin(axis_diff) + 1,
+                         std::begin(axis_diff) + axis_diff.size() / 2,
+                         std::end(axis_diff));
+        auto median_diff = *(std::begin(axis_diff) + axis_diff.size() / 2);
+        if(median_diff > (4 * min_diff)) min_diff = median_diff;
+      }
     }
-    return {range, min_diff, is_log};
+
+    return {range, min_diff, is_log, min, max};
   }
 
 } // namespace TimeSeriesUtils
diff --git a/include/Variable/private/VCTransaction.h b/include/Variable/private/VCTransaction.h
index 14745ab..92d2d95 100644
--- a/include/Variable/private/VCTransaction.h
+++ b/include/Variable/private/VCTransaction.h
@@ -65,7 +65,7 @@ public:
     {
       auto ds = _provider->getData(
           DataProviderParameters{{range}, _variable->metadata()});
-      if(ds) data.push_back(ds);
+      if(ds and ds->size()) data.push_back(ds); // skip empty dataSeries
     }
     if(_overwrite)
       _variable->setData(data, _range, true);
diff --git a/src/Variable/Variable2.cpp b/src/Variable/Variable2.cpp
index 0d6c40b..d99da6e 100644
--- a/src/Variable/Variable2.cpp
+++ b/src/Variable/Variable2.cpp
@@ -203,6 +203,18 @@ _merge(std::vector<TimeSeries::ITimeSerie*> source, const DateTimeRange& range)
                 std::back_inserter(dest->axis(ax_index)));
     }
   }
+  if constexpr(std::is_same_v<T, SpectrogramTimeSerie>)
+  {
+    auto d = std::dynamic_pointer_cast<SpectrogramTimeSerie>(dest);
+    if(std::isnan(d->max_sampling))
+    {
+      std::for_each(std::begin(source), std::end(source), [&d](auto src) {
+        auto s = dynamic_cast<SpectrogramTimeSerie*>(src);
+        if(!std::isnan(s->max_sampling)) { d->max_sampling = s->max_sampling; }
+        if(!std::isnan(s->min_sampling)) { d->min_sampling = s->min_sampling; }
+      });
+    }
+  }
   return dest;
 }
 
diff --git a/src/Variable/VariableController2.cpp b/src/Variable/VariableController2.cpp
index fc1f904..0ebf02b 100644
--- a/src/Variable/VariableController2.cpp
+++ b/src/Variable/VariableController2.cpp
@@ -264,6 +264,7 @@ class VariableController2::VariableController2Private
     }
     data.push_back(var->data().get()); // might be smarter
     var->setData(data, r, true);
+    std::for_each(std::begin(data), std::end(data), [](auto ts) { delete ts; });
   }
 
 public:
diff --git a/src/pybind11_wrappers/CoreWrappers.cpp b/src/pybind11_wrappers/CoreWrappers.cpp
index 0161d2c..0bc86e2 100644
--- a/src/pybind11_wrappers/CoreWrappers.cpp
+++ b/src/pybind11_wrappers/CoreWrappers.cpp
@@ -2,6 +2,7 @@
 
 #include "pywrappers_common.h"
 
+#include <Common/debug.h>
 #include <Data/DataSeriesType.h>
 #include <Data/IDataProvider.h>
 #include <Network/Downloader.h>
@@ -231,12 +232,13 @@ PYBIND11_MODULE(pysciqlopcore, m)
       .def(py::init<>())
       .def(py::init<const std::vector<std::size_t>>())
       .def(py::init([](py::array_t<double> t, py::array_t<double> y,
-                       py::array_t<double> values) {
-        auto t_s = t.size();
-        auto v_s = values.size();
-        assert(t.size() < values.size() or
-               t.size() == 0); // TODO check geometry
-        assert(y.size() == values.shape(1));
+                       py::array_t<double> values, double min_sampling,
+                       double max_sampling) {
+        if(t.size() >= values.size() and t.size() != 0)
+          SCIQLOP_ERROR(decltype(py::self), "Doesn't look like a Spectrogram");
+        if(y.size() != values.shape(1))
+          SCIQLOP_ERROR(decltype(py::self),
+                        "Y axis size and data shape are incompatible");
         SpectrogramTimeSerie::axis_t _t(t.size());
         SpectrogramTimeSerie::axis_t _y(y.size());
         SpectrogramTimeSerie::container_type<
@@ -247,7 +249,8 @@ PYBIND11_MODULE(pysciqlopcore, m)
         shape.push_back(values.shape(0));
         shape.push_back(values.shape(1));
         return SpectrogramTimeSerie(std::move(_t), std::move(_y),
-                                    std::move(_values), shape);
+                                    std::move(_values), shape, min_sampling,
+                                    max_sampling);
       }))
       .def("__getitem__",
            [](SpectrogramTimeSerie& ts,