diff --git a/core/include/Variable/Variable.h b/core/include/Variable/Variable.h
index cead7ff..c233bde 100644
--- a/core/include/Variable/Variable.h
+++ b/core/include/Variable/Variable.h
@@ -17,7 +17,10 @@ class QString;
 /**
  * @brief The Variable class represents a variable in SciQlop.
  */
-class Variable {
+class Variable : public QObject {
+
+    Q_OBJECT
+
 public:
     explicit Variable(const QString &name, const QString &unit, const QString &mission,
                       const SqpDateTime &dateTime);
@@ -25,14 +28,20 @@ public:
     QString name() const noexcept;
     QString mission() const noexcept;
     QString unit() const noexcept;
-
-    void addDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
+    SqpDateTime dateTime() const noexcept;
 
     /// @return the data of the variable, nullptr if there is no data
     IDataSeries *dataSeries() const noexcept;
 
+    bool contains(SqpDateTime dateTime);
+    void setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
+
 public slots:
-    void onXRangeChanged(SqpDateTime dateTime);
+    void onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
+
+signals:
+    void dataCacheUpdated();
+
 
 private:
     class VariablePrivate;
diff --git a/core/include/Variable/VariableController.h b/core/include/Variable/VariableController.h
index 0945b53..603c1e9 100644
--- a/core/include/Variable/VariableController.h
+++ b/core/include/Variable/VariableController.h
@@ -1,11 +1,14 @@
 #ifndef SCIQLOP_VARIABLECONTROLLER_H
 #define SCIQLOP_VARIABLECONTROLLER_H
 
+#include <Data/SqpDateTime.h>
+
 #include <QLoggingCategory>
 #include <QObject>
 
 #include <Common/spimpl.h>
 
+
 class IDataProvider;
 class TimeController;
 class Variable;
@@ -26,6 +29,10 @@ 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);
diff --git a/core/src/Variable/Variable.cpp b/core/src/Variable/Variable.cpp
index 19aa36d..43864d5 100644
--- a/core/src/Variable/Variable.cpp
+++ b/core/src/Variable/Variable.cpp
@@ -45,12 +45,25 @@ QString Variable::unit() const noexcept
     return impl->m_Unit;
 }
 
-void Variable::addDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept
+SqpDateTime Variable::dateTime() const noexcept
+{
+    return impl->m_DateTime;
+}
+
+void Variable::setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept
 {
     if (!impl->m_DataSeries) {
         impl->m_DataSeries = std::move(dataSeries);
     }
-    /// @todo : else, merge the two data series (if possible)
+}
+
+void Variable::onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
+{
+    if (impl->m_DataSeries) {
+        impl->m_DataSeries->merge(dataSeries.get());
+
+        emit dataCacheUpdated();
+    }
 }
 
 IDataSeries *Variable::dataSeries() const noexcept
@@ -58,10 +71,8 @@ IDataSeries *Variable::dataSeries() const noexcept
     return impl->m_DataSeries.get();
 }
 
-void Variable::onXRangeChanged(SqpDateTime dateTime)
+bool Variable::contains(SqpDateTime dateTime)
 {
-    qCInfo(LOG_Variable()) << "onXRangeChanged detected";
-
     if (!impl->m_DateTime.contains(dateTime)) {
         // The current variable dateTime isn't enough to display the dateTime requested.
         // We have to update it to the new dateTime requested.
@@ -70,5 +81,9 @@ void Variable::onXRangeChanged(SqpDateTime dateTime)
         qCInfo(LOG_Variable()) << "NEW DATE NEEDED";
 
         impl->m_DateTime = dateTime;
+
+        return false;
     }
+
+    return true;
 }
diff --git a/core/src/Variable/VariableController.cpp b/core/src/Variable/VariableController.cpp
index 8dc74ba..54124b6 100644
--- a/core/src/Variable/VariableController.cpp
+++ b/core/src/Variable/VariableController.cpp
@@ -1,3 +1,4 @@
+#include <Variable/Variable.h>
 #include <Variable/VariableCacheController.h>
 #include <Variable/VariableController.h>
 #include <Variable/VariableModel.h>
@@ -8,6 +9,7 @@
 #include <Time/TimeController.h>
 
 #include <QDateTime>
+#include <QElapsedTimer>
 #include <QMutex>
 #include <QThread>
 
@@ -44,6 +46,9 @@ struct VariableController::VariableControllerPrivate {
 
     TimeController *m_TimeController{nullptr};
     std::unique_ptr<VariableCacheController> m_VariableCacheController;
+
+    std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
+        m_VariableToProviderMap;
 };
 
 VariableController::VariableController(QObject *parent)
@@ -73,13 +78,6 @@ void VariableController::setTimeController(TimeController *timeController) noexc
 void VariableController::createVariable(const QString &name,
                                         std::shared_ptr<IDataProvider> provider) noexcept
 {
-    // TORM
-    //    auto dateTime = SqpDateTime{
-    //        // Remarks : we don't use toSecsSinceEpoch() here (method is for Qt 5.8 or above)
-    //        static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 00}}.toMSecsSinceEpoch()
-    //                            / 1000.),
-    //        static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 01}}.toMSecsSinceEpoch())
-    //            / 1000.};
 
     if (!impl->m_TimeController) {
         qCCritical(LOG_VariableController())
@@ -97,6 +95,14 @@ void VariableController::createVariable(const QString &name,
     if (auto newVariable = impl->m_VariableModel->createVariable(
             name, dateTime, generateDefaultDataSeries(*provider, dateTime))) {
 
+        // store the provider
+        impl->m_VariableToProviderMap[newVariable] = provider;
+        qRegisterMetaType<std::shared_ptr<IDataSeries> >();
+        qRegisterMetaType<SqpDateTime>();
+        connect(provider.get(), &IDataProvider::dataProvided, newVariable.get(),
+                &Variable::onAddDataSeries);
+
+
         // store in cache
         impl->m_VariableCacheController->addDateTime(newVariable, dateTime);
 
@@ -105,6 +111,41 @@ void VariableController::createVariable(const QString &name,
     }
 }
 
+
+void VariableController::requestDataLoading(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()) << "The slow s0 operation took" << timer.elapsed()
+                                         << "milliseconds";
+        auto dateTimeListNotInCache
+            = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
+        qCInfo(LOG_VariableController()) << "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()) << "The slow s2 operation took" << timer.elapsed()
+                                         << "milliseconds";
+
+        // store in cache
+        impl->m_VariableCacheController->addDateTime(variable, dateTime);
+        qCInfo(LOG_VariableController()) << "The slow s3 operation took" << timer.elapsed()
+                                         << "milliseconds";
+    }
+    else {
+        qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
+    }
+}
+
+
 void VariableController::initialize()
 {
     qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
diff --git a/core/src/Variable/VariableModel.cpp b/core/src/Variable/VariableModel.cpp
index 8325ee6..601f3cb 100644
--- a/core/src/Variable/VariableModel.cpp
+++ b/core/src/Variable/VariableModel.cpp
@@ -35,7 +35,7 @@ VariableModel::createVariable(const QString &name, const SqpDateTime &dateTime,
     /// @todo For the moment, the other data of the variable is initialized with default values
     auto variable = std::make_shared<Variable>(name, QStringLiteral("unit"),
                                                QStringLiteral("mission"), dateTime);
-    variable->addDataSeries(std::move(defaultDataSeries));
+    variable->setDataSeries(std::move(defaultDataSeries));
 
     impl->m_Variables.push_back(variable);
 
diff --git a/gui/include/DataSource/DataSourceWidget.h b/gui/include/DataSource/DataSourceWidget.h
index 4134f86..84e09dd 100644
--- a/gui/include/DataSource/DataSourceWidget.h
+++ b/gui/include/DataSource/DataSourceWidget.h
@@ -18,6 +18,7 @@ class DataSourceWidget : public QWidget {
 
 public:
     explicit DataSourceWidget(QWidget *parent = 0);
+    virtual ~DataSourceWidget() noexcept;
 
 public slots:
     /**
diff --git a/gui/include/Visualization/GraphPlottablesFactory.h b/gui/include/Visualization/GraphPlottablesFactory.h
index deaa485..35126e5 100644
--- a/gui/include/Visualization/GraphPlottablesFactory.h
+++ b/gui/include/Visualization/GraphPlottablesFactory.h
@@ -1,6 +1,8 @@
 #ifndef SCIQLOP_GRAPHPLOTTABLESFACTORY_H
 #define SCIQLOP_GRAPHPLOTTABLESFACTORY_H
 
+#include <Data/SqpDateTime.h>
+
 #include <QLoggingCategory>
 #include <QVector>
 
@@ -8,6 +10,7 @@
 
 Q_DECLARE_LOGGING_CATEGORY(LOG_GraphPlottablesFactory)
 
+class IDataSeries;
 class QCPAbstractPlottable;
 class QCustomPlot;
 class Variable;
@@ -27,6 +30,9 @@ struct GraphPlottablesFactory {
      */
     static QVector<QCPAbstractPlottable *> create(std::shared_ptr<Variable> variable,
                                                   QCustomPlot &plot) noexcept;
+
+    static void updateData(QVector<QCPAbstractPlottable *> plotableVect, IDataSeries *dataSeries,
+                           const SqpDateTime &dateTime);
 };
 
 #endif // SCIQLOP_GRAPHPLOTTABLESFACTORY_H
diff --git a/gui/include/Visualization/VisualizationGraphWidget.h b/gui/include/Visualization/VisualizationGraphWidget.h
index 710eba6..d23cbc5 100644
--- a/gui/include/Visualization/VisualizationGraphWidget.h
+++ b/gui/include/Visualization/VisualizationGraphWidget.h
@@ -34,6 +34,9 @@ public:
     void close() override;
     QString name() const override;
 
+    void updateDisplay(std::shared_ptr<Variable> variable);
+
+
 private:
     Ui::VisualizationGraphWidget *ui;
 
@@ -46,6 +49,8 @@ private slots:
 
     /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
     void onMouseWheel(QWheelEvent *event) noexcept;
+
+    void onDataCacheVariableUpdated();
 };
 
 #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
diff --git a/gui/src/Visualization/GraphPlottablesFactory.cpp b/gui/src/Visualization/GraphPlottablesFactory.cpp
index ab384a9..3748d8f 100644
--- a/gui/src/Visualization/GraphPlottablesFactory.cpp
+++ b/gui/src/Visualization/GraphPlottablesFactory.cpp
@@ -5,6 +5,8 @@
 
 #include <Variable/Variable.h>
 
+#include <QElapsedTimer>
+
 Q_LOGGING_CATEGORY(LOG_GraphPlottablesFactory, "GraphPlottablesFactory")
 
 namespace {
@@ -28,15 +30,55 @@ QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
     }
 }
 
-QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot)
+void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSeries,
+                      const SqpDateTime &dateTime)
+{
+    QElapsedTimer timer;
+    timer.start();
+    if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
+        // Clean the graph
+        qCDebug(LOG_GraphPlottablesFactory()) << "The slow s1 operation took" << timer.elapsed()
+                                              << "milliseconds";
+        // NAIVE approch
+        const auto &xData = scalarSeries.xAxisData()->data();
+        const auto &valuesData = scalarSeries.valuesData()->data();
+
+        auto xValue = QVector<double>();
+        auto vValue = QVector<double>();
+
+        const auto count = xData.count();
+        auto ite = 0;
+        for (auto i = 0; i < count; ++i) {
+            const auto x = xData.at(i);
+            if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) {
+                xValue.push_back(x);
+                vValue.push_back(valuesData.at(i));
+                ++ite;
+            }
+        }
+
+        qcpGraph->setData(xValue, vValue);
+
+        qCDebug(LOG_GraphPlottablesFactory()) << "The slow s2 operation took" << timer.elapsed()
+                                              << "milliseconds";
+    }
+    else {
+        /// @todo DEBUG
+    }
+}
+
+QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot,
+                                                  const SqpDateTime &dateTime)
 {
     auto component = plot.addGraph();
 
     if (component) {
-        // Graph data
+        //        // Graph data
         component->setData(scalarSeries.xAxisData()->data(), scalarSeries.valuesData()->data(),
                            true);
 
+        updateScalarData(component, scalarSeries, dateTime);
+
         // Axes properties
         /// @todo : for the moment, no control is performed on the axes: the units and the tickers
         /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
@@ -75,7 +117,7 @@ QVector<QCPAbstractPlottable *> GraphPlottablesFactory::create(std::shared_ptr<V
         // Gets the data series of the variable to call the creation of the right components
         // according to its type
         if (auto scalarSeries = dynamic_cast<ScalarSeries *>(variable->dataSeries())) {
-            result.append(createScalarSeriesComponent(*scalarSeries, plot));
+            result.append(createScalarSeriesComponent(*scalarSeries, plot, variable->dateTime()));
         }
         else {
             qCDebug(LOG_GraphPlottablesFactory())
@@ -89,3 +131,21 @@ QVector<QCPAbstractPlottable *> GraphPlottablesFactory::create(std::shared_ptr<V
 
     return result;
 }
+
+void GraphPlottablesFactory::updateData(QVector<QCPAbstractPlottable *> plotableVect,
+                                        IDataSeries *dataSeries, const SqpDateTime &dateTime)
+{
+    if (auto scalarSeries = dynamic_cast<ScalarSeries *>(dataSeries)) {
+        if (plotableVect.size() == 1) {
+            updateScalarData(plotableVect.at(0), *scalarSeries, dateTime);
+        }
+        else {
+            qCCritical(LOG_GraphPlottablesFactory()) << QObject::tr(
+                "Can't update Data of a scalarSeries because there is not only one component "
+                "associated");
+        }
+    }
+    else {
+        /// @todo DEBUG
+    }
+}
diff --git a/gui/src/Visualization/VisualizationGraphWidget.cpp b/gui/src/Visualization/VisualizationGraphWidget.cpp
index 897dc7c..6747bda 100644
--- a/gui/src/Visualization/VisualizationGraphWidget.cpp
+++ b/gui/src/Visualization/VisualizationGraphWidget.cpp
@@ -3,7 +3,12 @@
 #include "Visualization/IVisualizationWidgetVisitor.h"
 #include "ui_VisualizationGraphWidget.h"
 
+#include <Data/ArrayData.h>
+#include <Data/IDataSeries.h>
+#include <SqpApplication.h>
 #include <Variable/Variable.h>
+#include <Variable/VariableController.h>
+
 #include <unordered_map>
 
 Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
@@ -21,7 +26,8 @@ const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
 struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
 
     // 1 variable -> n qcpplot
-    std::unordered_map<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMap;
+    std::unordered_multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *>
+        m_VariableToPlotMultiMap;
 };
 
 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
@@ -58,8 +64,11 @@ void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
     auto createdPlottables = GraphPlottablesFactory::create(variable, *ui->widget);
 
     for (auto createdPlottable : qAsConst(createdPlottables)) {
-        impl->m_VariableToPlotMap.insert({variable, createdPlottable});
+        impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
     }
+
+    connect(variable.get(), &Variable::dataCacheUpdated, this,
+            &VisualizationGraphWidget::onDataCacheVariableUpdated);
 }
 
 void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
@@ -98,9 +107,20 @@ QString VisualizationGraphWidget::name() const
 
 void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
 {
-    for (auto it = impl->m_VariableToPlotMap.cbegin(); it != impl->m_VariableToPlotMap.cend();
-         ++it) {
-        it->first->onXRangeChanged(SqpDateTime{t2.lower, t2.upper});
+
+    qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged");
+
+    for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
+         it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
+        auto variable = it->first;
+        auto tolerance = 0.1 * (t2.upper - t2.lower);
+        auto dateTime = SqpDateTime{t2.lower - tolerance, t2.upper + tolerance};
+
+        qCInfo(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged")
+                                               << variable->dataSeries()->xAxisData()->size();
+        if (!variable->contains(dateTime)) {
+            sqpApp->variableController().requestDataLoading(variable, dateTime);
+        }
     }
 }
 
@@ -120,3 +140,27 @@ void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
 
     ui->widget->axisRect()->setRangeZoom(zoomOrientations);
 }
+
+void VisualizationGraphWidget::onDataCacheVariableUpdated()
+{
+    for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
+         it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
+        auto variable = it->first;
+        GraphPlottablesFactory::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
+                                           variable->dataSeries(), variable->dateTime());
+    }
+}
+
+void VisualizationGraphWidget::updateDisplay(std::shared_ptr<Variable> variable)
+{
+    auto abstractPlotableItPair = impl->m_VariableToPlotMultiMap.equal_range(variable);
+
+    auto abstractPlotableVect = QVector<QCPAbstractPlottable *>{};
+
+    for (auto it = abstractPlotableItPair.first; it != abstractPlotableItPair.second; ++it) {
+        abstractPlotableVect.push_back(it->second);
+    }
+
+    GraphPlottablesFactory::updateData(abstractPlotableVect, variable->dataSeries(),
+                                       variable->dateTime());
+}