diff --git a/core/include/Data/ArrayData.h b/core/include/Data/ArrayData.h
index 5be205f..c466119 100644
--- a/core/include/Data/ArrayData.h
+++ b/core/include/Data/ArrayData.h
@@ -44,9 +44,9 @@ public:
      * @remarks this method is only available for a unidimensional ArrayData
      */
     template <int D = Dim, typename = std::enable_if_t<D == 1> >
-    QVector<double> data() const noexcept
+    const QVector<double> &data() const noexcept
     {
-        return m_Data.at(0);
+        return m_Data[0];
     }
 
     /**
@@ -61,10 +61,10 @@ public:
 
     // TODO Comment
     template <int D = Dim, typename = std::enable_if_t<D == 1> >
-    void merge(ArrayData<1> *arrayData)
+    void merge(const ArrayData<1> &arrayData)
     {
         if (!m_Data.empty()) {
-            m_Data[0] += arrayData->data();
+            m_Data[0] += arrayData.data();
         }
     }
 
diff --git a/core/include/Data/DataSeries.h b/core/include/Data/DataSeries.h
index 31825bd..46ee991 100644
--- a/core/include/Data/DataSeries.h
+++ b/core/include/Data/DataSeries.h
@@ -40,8 +40,8 @@ public:
     void merge(IDataSeries *dataSeries) override
     {
         if (auto dimDataSeries = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
-            m_XAxisData->merge(dimDataSeries->xAxisData().get());
-            m_ValuesData->merge(dimDataSeries->valuesData().get());
+            m_XAxisData->merge(*dimDataSeries->xAxisData());
+            m_ValuesData->merge(*dimDataSeries->valuesData());
         }
         else {
             qCWarning(LOG_DataSeries())
diff --git a/core/include/Data/SqpDateTime.h b/core/include/Data/SqpDateTime.h
index dc43dc1..c0f73c1 100644
--- a/core/include/Data/SqpDateTime.h
+++ b/core/include/Data/SqpDateTime.h
@@ -2,6 +2,10 @@
 #define SCIQLOP_SQPDATETIME_H
 
 #include <QObject>
+
+#include <QDateTime>
+#include <QDebug>
+
 /**
  * @brief The SqpDateTime struct holds the information of time parameters
  */
@@ -22,6 +26,16 @@ struct SqpDateTime {
     }
 };
 
+inline QDebug operator<<(QDebug d, SqpDateTime obj)
+{
+    auto tendDateTimeStart = QDateTime::fromMSecsSinceEpoch(obj.m_TStart * 1000);
+    auto tendDateTimeEnd = QDateTime::fromMSecsSinceEpoch(obj.m_TEnd * 1000);
+
+    //        QDebug << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
+    d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
+    return d;
+}
+
 // Required for using shared_ptr in signals/slots
 Q_DECLARE_METATYPE(SqpDateTime)
 
diff --git a/core/include/Variable/Variable.h b/core/include/Variable/Variable.h
index c6688c0..f654f78 100644
--- a/core/include/Variable/Variable.h
+++ b/core/include/Variable/Variable.h
@@ -42,7 +42,7 @@ public slots:
     void onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
 
 signals:
-    void dataCacheUpdated();
+    void updated();
 
 
 private:
diff --git a/core/include/Variable/VariableCacheController.h b/core/include/Variable/VariableCacheController.h
index 2fd48b2..dd7b988 100644
--- a/core/include/Variable/VariableCacheController.h
+++ b/core/include/Variable/VariableCacheController.h
@@ -5,10 +5,15 @@
 
 #include <Data/SqpDateTime.h>
 
+#include <QLoggingCategory>
+
 #include <Common/spimpl.h>
 
 class Variable;
 
+Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController)
+
+
 /// This class aims to store in the cache all of the dateTime already requested to the variable.
 class VariableCacheController : public QObject {
     Q_OBJECT
@@ -25,6 +30,8 @@ public:
 
     QVector<SqpDateTime> dateCacheList(std::shared_ptr<Variable> variable) const noexcept;
 
+    void displayCache(std::shared_ptr<Variable> variable);
+
 private:
     class VariableCacheControllerPrivate;
     spimpl::unique_impl_ptr<VariableCacheControllerPrivate> impl;
diff --git a/core/include/Variable/VariableController.h b/core/include/Variable/VariableController.h
index 603c1e9..2da1749 100644
--- a/core/include/Variable/VariableController.h
+++ b/core/include/Variable/VariableController.h
@@ -30,14 +30,13 @@ public:
     void setTimeController(TimeController *timeController) noexcept;
 
 
-    /// Request the data loading of the variable whithin dateTime
-    void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
-
 signals:
     /// Signal emitted when a variable has been created
     void variableCreated(std::shared_ptr<Variable> variable);
 
 public slots:
+    /// Request the data loading of the variable whithin dateTime
+    void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
     /**
      * Creates a new variable and adds it to the model
      * @param name the name of the new variable
diff --git a/core/src/Variable/Variable.cpp b/core/src/Variable/Variable.cpp
index ff099c6..899ca31 100644
--- a/core/src/Variable/Variable.cpp
+++ b/core/src/Variable/Variable.cpp
@@ -67,7 +67,7 @@ void Variable::onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
     if (impl->m_DataSeries) {
         impl->m_DataSeries->merge(dataSeries.get());
 
-        emit dataCacheUpdated();
+        emit updated();
     }
 }
 
diff --git a/core/src/Variable/VariableCacheController.cpp b/core/src/Variable/VariableCacheController.cpp
index 34cb514..f151b4d 100644
--- a/core/src/Variable/VariableCacheController.cpp
+++ b/core/src/Variable/VariableCacheController.cpp
@@ -3,6 +3,8 @@
 #include "Variable/Variable.h"
 #include <unordered_map>
 
+Q_LOGGING_CATEGORY(LOG_VariableCacheController, "VariableCacheController")
+
 struct VariableCacheController::VariableCacheControllerPrivate {
 
     std::unordered_map<std::shared_ptr<Variable>, QVector<SqpDateTime> >
@@ -156,15 +158,26 @@ void VariableCacheController::VariableCacheControllerPrivate::addInCacheDataBySt
         // ts localised between to interval: let's localized te
         addInCacheDataByEnd(dateTime, dateTimeList, notInCache, cacheIndex, currentTStart);
     }
-    else if (dateTime.m_TStart < currentDateTimeI.m_TEnd) {
-        // ts not localised before the current interval: we need to look at the next interval
-        // We can assume now current tstart is the last interval tend, because data between them are
-        // in the cache
-        addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex,
-                              currentDateTimeI.m_TEnd);
+    else if (currentTStart < currentDateTimeI.m_TEnd) {
+        if (dateTime.m_TEnd > currentDateTimeI.m_TEnd) {
+            // ts not localised before the current interval: we need to look at the next interval
+            // We can assume now current tstart is the last interval tend, because data between them
+            // are
+            // in the cache
+            addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex,
+                                  currentDateTimeI.m_TEnd);
+        }
     }
     else {
         // ts not localised before the current interval: we need to look at the next interval
         addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex, currentTStart);
     }
 }
+
+
+void VariableCacheController::displayCache(std::shared_ptr<Variable> variable)
+{
+    auto variableDateTimeList = impl->m_VariableToSqpDateTimeListMap.at(variable);
+    qCInfo(LOG_VariableCacheController()) << tr("VariableCacheController::displayCache")
+                                          << variableDateTimeList;
+}
diff --git a/core/src/Variable/VariableController.cpp b/core/src/Variable/VariableController.cpp
index 90d1368..355cee0 100644
--- a/core/src/Variable/VariableController.cpp
+++ b/core/src/Variable/VariableController.cpp
@@ -9,7 +9,6 @@
 #include <Time/TimeController.h>
 
 #include <QDateTime>
-#include <QElapsedTimer>
 #include <QMutex>
 #include <QThread>
 
@@ -112,33 +111,27 @@ void VariableController::createVariable(const QString &name,
 }
 
 
-void VariableController::requestDataLoading(std::shared_ptr<Variable> variable,
-                                            const SqpDateTime &dateTime)
+void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
+                                              const SqpDateTime &dateTime)
 {
     // we want to load data of the variable for the dateTime.
     // First we check if the cache contains some of them.
     // For the other, we ask the provider to give them.
     if (variable) {
 
-        QElapsedTimer timer;
-        timer.start();
-        qCInfo(LOG_VariableController()) << "TORM: The slow s0 operation took" << timer.elapsed()
-                                         << "milliseconds";
         auto dateTimeListNotInCache
             = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
-        qCInfo(LOG_VariableController()) << "TORM: The slow s1 operation took" << timer.elapsed()
-                                         << "milliseconds";
 
-        // Ask the provider for each data on the dateTimeListNotInCache
-        impl->m_VariableToProviderMap.at(variable)->requestDataLoading(dateTimeListNotInCache);
-
-        qCInfo(LOG_VariableController()) << "TORM: The slow s2 operation took" << timer.elapsed()
-                                         << "milliseconds";
-
-        // store in cache
-        impl->m_VariableCacheController->addDateTime(variable, dateTime);
-        qCInfo(LOG_VariableController()) << "TORM: The slow s3 operation took" << timer.elapsed()
-                                         << "milliseconds";
+        if (!dateTimeListNotInCache.empty()) {
+            // Ask the provider for each data on the dateTimeListNotInCache
+            impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
+                std::move(dateTimeListNotInCache));
+            // store in cache
+            impl->m_VariableCacheController->addDateTime(variable, dateTime);
+        }
+        else {
+            emit variable->updated();
+        }
     }
     else {
         qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
diff --git a/core/tests/Variable/TestVariableCacheController.cpp b/core/tests/Variable/TestVariableCacheController.cpp
index 37e357d..6a6600d 100644
--- a/core/tests/Variable/TestVariableCacheController.cpp
+++ b/core/tests/Variable/TestVariableCacheController.cpp
@@ -241,6 +241,16 @@ void TestVariableCacheController::testProvideNotInCacheDateTimeList()
     notInCacheSqp = notInCach.at(1);
     QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
     QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+
+
+    // 12th case ts0 < ts < te0
+    ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 10, 0}};
+    te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 50, 0}};
+    sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
+                      static_cast<double>(te.toMSecsSinceEpoch())};
+
+    notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
+    QCOMPARE(notInCach.size(), 0);
 }
 
 
diff --git a/gui/include/Visualization/VisualizationGraphWidget.h b/gui/include/Visualization/VisualizationGraphWidget.h
index 15b93e9..5e0d037 100644
--- a/gui/include/Visualization/VisualizationGraphWidget.h
+++ b/gui/include/Visualization/VisualizationGraphWidget.h
@@ -13,6 +13,7 @@
 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
 
 class QCPRange;
+class SqpDateTime;
 class Variable;
 
 namespace Ui {
@@ -37,6 +38,9 @@ public:
 
     void updateDisplay(std::shared_ptr<Variable> variable);
 
+signals:
+    void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
+
 
 private:
     Ui::VisualizationGraphWidget *ui;
diff --git a/gui/src/Visualization/VisualizationGraphHelper.cpp b/gui/src/Visualization/VisualizationGraphHelper.cpp
index f4a0122..da5e732 100644
--- a/gui/src/Visualization/VisualizationGraphHelper.cpp
+++ b/gui/src/Visualization/VisualizationGraphHelper.cpp
@@ -37,30 +37,32 @@ void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSerie
     timer.start();
     if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
         // Clean the graph
-        qCDebug(LOG_VisualizationGraphHelper()) << "The slow s1 operation took" << timer.elapsed()
-                                                << "milliseconds";
         // NAIVE approch
         const auto &xData = scalarSeries.xAxisData()->data();
         const auto &valuesData = scalarSeries.valuesData()->data();
+        const auto count = xData.count();
+        qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache" << xData.count();
 
-        auto xValue = QVector<double>();
-        auto vValue = QVector<double>();
+        auto xValue = QVector<double>(count);
+        auto vValue = QVector<double>(count);
 
-        const auto count = xData.count();
-        auto ite = 0;
+        int n = 0;
         for (auto i = 0; i < count; ++i) {
-            const auto x = xData.at(i);
+            const auto x = xData[i];
             if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) {
-                xValue.push_back(x);
-                vValue.push_back(valuesData.at(i));
-                ++ite;
+                xValue[n] = x;
+                vValue[n] = valuesData[i];
+                ++n;
             }
         }
 
-        qcpGraph->setData(xValue, vValue);
+        xValue.resize(n);
+        vValue.resize(n);
 
-        qCDebug(LOG_VisualizationGraphHelper()) << "The slow s2 operation took" << timer.elapsed()
-                                                << "milliseconds";
+        qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed"
+                                               << xValue.count();
+
+        qcpGraph->setData(xValue, vValue);
     }
     else {
         /// @todo DEBUG
diff --git a/gui/src/Visualization/VisualizationGraphWidget.cpp b/gui/src/Visualization/VisualizationGraphWidget.cpp
index 213979f..059beb8 100644
--- a/gui/src/Visualization/VisualizationGraphWidget.cpp
+++ b/gui/src/Visualization/VisualizationGraphWidget.cpp
@@ -57,6 +57,9 @@ VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget 
     ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
             &VisualizationGraphWidget::onGraphMenuRequested);
+
+    connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
+            &VariableController::onRequestDataLoading);
 }
 
 
@@ -74,7 +77,7 @@ void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
         impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
     }
 
-    connect(variable.get(), SIGNAL(dataCacheUpdated()), this, SLOT(onDataCacheVariableUpdated()));
+    connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
 }
 
 void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
@@ -142,9 +145,6 @@ void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange
          it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
 
         auto variable = it->first;
-        qCInfo(LOG_VisualizationGraphWidget())
-            << tr("TORM: VisualizationGraphWidget::onRangeChanged")
-            << variable->dataSeries()->xAxisData()->size();
         auto dateTime = SqpDateTime{t2.lower, t2.upper};
 
         if (!variable->contains(dateTime)) {
@@ -179,8 +179,7 @@ void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange
             variable->setDateTime(dateTime);
 
             // CHangement detected, we need to ask controller to request data loading
-            sqpApp->variableController().requestDataLoading(variable,
-                                                            variableDateTimeWithTolerance);
+            emit requestDataLoading(variable, variableDateTimeWithTolerance);
         }
     }
 }
diff --git a/plugins/mockplugin/src/CosinusProvider.cpp b/plugins/mockplugin/src/CosinusProvider.cpp
index cd9ef2b..ee66ccf 100644
--- a/plugins/mockplugin/src/CosinusProvider.cpp
+++ b/plugins/mockplugin/src/CosinusProvider.cpp
@@ -5,6 +5,8 @@
 
 #include <cmath>
 
+#include <QDateTime>
+
 Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
 
 std::unique_ptr<IDataSeries>
@@ -16,6 +18,7 @@ CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
     auto start = dateTime.m_TStart;
     auto end = dateTime.m_TEnd;
 
+
     // We assure that timerange is valid
     if (end < start) {
         std::swap(start, end);
@@ -47,10 +50,12 @@ void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeLis
 
 std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTime &dateTime)
 {
+    auto dataIndex = 0;
 
     // Gets the timerange from the parameters
-    auto start = dateTime.m_TStart;
-    auto end = dateTime.m_TEnd;
+    double freq = 100.0;
+    double start = dateTime.m_TStart * freq; // 100 htz
+    double end = dateTime.m_TEnd * freq;     // 100 htz
 
     // We assure that timerange is valid
     if (end < start) {
@@ -61,11 +66,9 @@ std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTi
     auto scalarSeries
         = std::make_shared<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
 
-    auto dataIndex = 0;
     for (auto time = start; time < end; ++time, ++dataIndex) {
-        scalarSeries->setData(dataIndex, time, std::cos(time));
+        const auto timeOnFreq = time / freq;
+        scalarSeries->setData(dataIndex, timeOnFreq, std::cos(timeOnFreq));
     }
-
-
     return scalarSeries;
 }