GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r455:a774a1678512

Merge branch 'feature/DateTimeUTC' into develop

Alexandre Leroux -

r455:a774a1678512

parent child

Context file:

r455:a774a1678512

Collapse all files

core/include/Common/DateUtils.h created 644 +19 0

@@ -0,0 +1,19
	1	#ifndef SCIQLOP_DATEUTILS_H
	2	#define SCIQLOP_DATEUTILS_H
	3
	4	#include "CoreGlobal.h"
	5
	6	#include <QDateTime>
	7
	8	/**
	9	* Utility class with methods for dates
	10	*/
	11	struct SCIQLOP_CORE_EXPORT DateUtils {
	12	/// Converts seconds (since epoch) to datetime. By default, the datetime is in UTC
	13	static QDateTime dateTime(double secs, Qt::TimeSpec timeSpec = Qt::UTC) noexcept;
	14
	15	/// Converts datetime to seconds since epoch
	16	static double secondsSinceEpoch(const QDateTime &dateTime) noexcept;
	17	};
	18
	19	#endif // SCIQLOP_DATEUTILS_H

core/src/Common/DateUtils.cpp created 644 +13 0

@@ -0,0 +1,13
	1	#include "Common/DateUtils.h"
	2
	3	QDateTime DateUtils::dateTime(double secs, Qt::TimeSpec timeSpec) noexcept
	4	{
	5	// Uses msecs to be Qt 4 compatible
	6	return QDateTime::fromMSecsSinceEpoch(secs * 1000., timeSpec);
	7	}
	8
	9	double DateUtils::secondsSinceEpoch(const QDateTime &dateTime) noexcept
	10	{
	11	// Uses msecs to be Qt 4 compatible
	12	return dateTime.toMSecsSinceEpoch() / 1000.;
	13	}

app/src/MainWindow.cpp 0 -1

             /*------------------------------------------------------------------------------
             -- This file is a part of the SciQLop Software
             -- Copyright (C) 2017, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "MainWindow.h"
             #include "ui_MainWindow.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceWidget.h>
             #include <Settings/SqpSettingsDialog.h>
             #include <Settings/SqpSettingsGeneralWidget.h>
             #include <SidePane/SqpSidePane.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <TimeWidget/TimeWidget.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationController.h>
             #include <QAction>
             #include <QDate>
-            #include <QDateTime>
             #include <QDir>
             #include <QFileDialog>
             #include <QToolBar>
             #include <QToolButton>
             #include <memory.h>
             #include "iostream"
             Q_LOGGING_CATEGORY(LOG_MainWindow, "MainWindow")
             namespace {
             const auto LEFTMAININSPECTORWIDGETSPLITTERINDEX = 0;
             const auto LEFTINSPECTORSIDEPANESPLITTERINDEX = 1;
             const auto VIEWPLITTERINDEX = 2;
             const auto RIGHTINSPECTORSIDEPANESPLITTERINDEX = 3;
             const auto RIGHTMAININSPECTORWIDGETSPLITTERINDEX = 4;
             }
             class MainWindow::MainWindowPrivate {
             public:
                 explicit MainWindowPrivate(MainWindow *mainWindow)
                         : m_LastOpenLeftInspectorSize{},
                           m_LastOpenRightInspectorSize{},
                           m_GeneralSettingsWidget{new SqpSettingsGeneralWidget{mainWindow}},
                           m_SettingsDialog{new SqpSettingsDialog{mainWindow}}
                 {
                 }
                 QSize m_LastOpenLeftInspectorSize;
                 QSize m_LastOpenRightInspectorSize;
                 /// General settings widget. MainWindow has the ownership
                 SqpSettingsGeneralWidget *m_GeneralSettingsWidget;
                 /// Settings dialog. MainWindow has the ownership
                 SqpSettingsDialog *m_SettingsDialog;
             };
             MainWindow::MainWindow(QWidget *parent)
                     : QMainWindow{parent},
                       m_Ui{new Ui::MainWindow},
                       impl{spimpl::make_unique_impl<MainWindowPrivate>(this)}
             {
                 m_Ui->setupUi(this);
                 m_Ui->splitter->setCollapsible(LEFTINSPECTORSIDEPANESPLITTERINDEX, false);
                 m_Ui->splitter->setCollapsible(RIGHTINSPECTORSIDEPANESPLITTERINDEX, false);
                 auto leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
                 auto openLeftInspectorAction = new QAction{QIcon{
                                                                ":/icones/previous.png",
                                                            },
                                                            tr("Show/hide the left inspector"), this};
                 auto spacerLeftTop = new QWidget{};
                 spacerLeftTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerLeftBottom = new QWidget{};
                 spacerLeftBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 leftSidePane->addWidget(spacerLeftTop);
                 leftSidePane->addAction(openLeftInspectorAction);
                 leftSidePane->addWidget(spacerLeftBottom);
                 auto rightSidePane = m_Ui->rightInspectorSidePane->sidePane();
                 auto openRightInspectorAction = new QAction{QIcon{
                                                                 ":/icones/next.png",
                                                             },
                                                             tr("Show/hide the right inspector"), this};
                 auto spacerRightTop = new QWidget{};
                 spacerRightTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerRightBottom = new QWidget{};
                 spacerRightBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 rightSidePane->addWidget(spacerRightTop);
                 rightSidePane->addAction(openRightInspectorAction);
                 rightSidePane->addWidget(spacerRightBottom);
                 openLeftInspectorAction->setCheckable(true);
                 openRightInspectorAction->setCheckable(true);
                 auto openInspector = [this](bool checked, bool right, auto action) {
                     action->setIcon(QIcon{(checked xor right) ? ":/icones/next.png" : ":/icones/previous.png"});
                     auto &lastInspectorSize
                         = right ? impl->m_LastOpenRightInspectorSize : impl->m_LastOpenLeftInspectorSize;
                     auto nextInspectorSize = right ? m_Ui->rightMainInspectorWidget->size()
                                                    : m_Ui->leftMainInspectorWidget->size();
                     // Update of the last opened geometry
                     if (checked) {
                         lastInspectorSize = nextInspectorSize;
                     }
                     auto startSize = lastInspectorSize;
                     auto endSize = startSize;
                     endSize.setWidth(0);
                     auto splitterInspectorIndex
                         = right ? RIGHTMAININSPECTORWIDGETSPLITTERINDEX : LEFTMAININSPECTORWIDGETSPLITTERINDEX;
                     auto currentSizes = m_Ui->splitter->sizes();
                     if (checked) {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] -= lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] += lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                     else {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] += lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] -= lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                 };
                 connect(openLeftInspectorAction, &QAction::triggered,
                         [openInspector, openLeftInspectorAction](bool checked) {
                             openInspector(checked, false, openLeftInspectorAction);
                         });
                 connect(openRightInspectorAction, &QAction::triggered,
                         [openInspector, openRightInspectorAction](bool checked) {
                             openInspector(checked, true, openRightInspectorAction);
                         });
                 // //// //
                 // Menu //
                 // //// //
                 this->menuBar()->addAction(tr("File"));
                 auto toolsMenu = this->menuBar()->addMenu(tr("Tools"));
                 toolsMenu->addAction(tr("Settings..."), [this]() {
                     // Loads settings
                     impl->m_SettingsDialog->loadSettings();
                     // Open settings dialog and save settings if the dialog is accepted
                     if (impl->m_SettingsDialog->exec() == QDialog::Accepted) {
                         impl->m_SettingsDialog->saveSettings();
                     }
                 });
                 auto mainToolBar = this->addToolBar(QStringLiteral("MainToolBar"));
                 auto timeWidget = new TimeWidget{};
                 mainToolBar->addWidget(timeWidget);
                 // //////// //
                 // Settings //
                 // //////// //
                 // Registers "general settings" widget to the settings dialog
                 impl->m_SettingsDialog->registerWidget(QStringLiteral("General"),
                                                        impl->m_GeneralSettingsWidget);
                 // /////////// //
                 // Connections //
                 // /////////// //
                 // Controllers / controllers connections
                 connect(&sqpApp->timeController(), SIGNAL(timeUpdated(SqpDateTime)),
                         &sqpApp->variableController(), SLOT(onDateTimeOnSelection(SqpDateTime)));
                 // Widgets / controllers connections
                 // DataSource
                 connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem *)),
                         m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
                 // Time
                 connect(timeWidget, SIGNAL(timeUpdated(SqpDateTime)), &sqpApp->timeController(),
                         SLOT(onTimeToUpdate(SqpDateTime)));
                 // Visualization
                 connect(&sqpApp->visualizationController(),
                         SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), m_Ui->view,
                         SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable>)));
                 connect(&sqpApp->visualizationController(),
                         SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpDateTime &)), m_Ui->view,
                         SLOT(onRangeChanged(std::shared_ptr<Variable>, const SqpDateTime &)));
                 // Widgets / widgets connections
                 // For the following connections, we use DirectConnection to allow each widget that can
                 // potentially attach a menu to the variable's menu to do so before this menu is displayed.
                 // The order of connections is also important, since it determines the order in which each
                 // widget will attach its menu
                 connect(
                     m_Ui->variableInspectorWidget,
                     SIGNAL(tableMenuAboutToBeDisplayed(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
                     m_Ui->view, SLOT(attachVariableMenu(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
                     Qt::DirectConnection);
             }
             MainWindow::~MainWindow()
             {
             }
             void MainWindow::changeEvent(QEvent *e)
             {
                 QMainWindow::changeEvent(e);
                 switch (e->type()) {
                     case QEvent::LanguageChange:
                         m_Ui->retranslateUi(this);
                         break;
                     default:
                         break;
                 }
             }

core/include/Data/IDataSeries.h +1 -1

             #ifndef SCIQLOP_IDATASERIES_H
             #define SCIQLOP_IDATASERIES_H
             #include <Common/MetaTypes.h>
             #include <memory>
             #include <QString>
             template <int Dim>
             class ArrayData;
             struct Unit {
                 explicit Unit(const QString &name = {}, bool timeUnit = false)
                         : m_Name{name}, m_TimeUnit{timeUnit}
                 {
                 }
                 inline bool operator==(const Unit &other) const
                 {
                     return std::tie(m_Name, m_TimeUnit) == std::tie(other.m_Name, other.m_TimeUnit);
                 }
                 inline bool operator!=(const Unit &other) const { return !(*this == other); }
                 QString m_Name;  ///< Unit name
-                bool m_TimeUnit; ///< The unit is a unit of time
+                bool m_TimeUnit; ///< The unit is a unit of time (UTC)
             };
             /**
              * @brief The IDataSeries aims to declare a data series.
              *
              * A data series is an entity that contains at least :
              * - one dataset representing the x-axis
              * - one dataset representing the values
              *
              * Each dataset is represented by an ArrayData, and is associated with a unit.
              *
              * An ArrayData can be unidimensional or two-dimensional, depending on the implementation of the
              * IDataSeries. The x-axis dataset is always unidimensional.
              *
              * @sa ArrayData
              */
             class IDataSeries {
             public:
                 virtual ~IDataSeries() noexcept = default;
                 /// Returns the x-axis dataset
                 virtual std::shared_ptr<ArrayData<1> > xAxisData() = 0;
                 /// Returns the x-axis dataset (as const)
                 virtual const std::shared_ptr<ArrayData<1> > xAxisData() const = 0;
                 virtual Unit xAxisUnit() const = 0;
                 virtual Unit valuesUnit() const = 0;
                 virtual void merge(IDataSeries *dataSeries) = 0;
                 virtual std::unique_ptr<IDataSeries> clone() const = 0;
                 virtual void lockRead() = 0;
                 virtual void lockWrite() = 0;
                 virtual void unlock() = 0;
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(IDATASERIES_PTR_REGISTRY, std::shared_ptr<IDataSeries>)
             #endif // SCIQLOP_IDATASERIES_H

core/include/Data/SqpDateTime.h +5 -6

             #ifndef SCIQLOP_SQPDATETIME_H
             #define SCIQLOP_SQPDATETIME_H
             #include <QObject>
-            #include <QDateTime>
             #include <QDebug>
+            #include <Common/DateUtils.h>
             #include <Common/MetaTypes.h>
             /**
              * @brief The SqpDateTime struct holds the information of time parameters
              */
             struct SqpDateTime {
-                /// Start time
+                /// Start time (UTC)
                 double m_TStart;
-                /// End time
+                /// End time (UTC)
                 double m_TEnd;
                 bool contains(const SqpDateTime &dateTime) const noexcept
                 {
                     return (m_TStart <= dateTime.m_TStart && m_TEnd >= dateTime.m_TEnd);
                 }
                 bool intersect(const SqpDateTime &dateTime) const noexcept
                 {
                     return (m_TEnd >= dateTime.m_TStart && m_TStart <= dateTime.m_TEnd);
                 }
             };
             inline QDebug operator<<(QDebug d, SqpDateTime obj)
             {
-                auto tendDateTimeStart = QDateTime::fromMSecsSinceEpoch(obj.m_TStart * 1000);
+                auto tendDateTimeStart = DateUtils::dateTime(obj.m_TStart);
-                auto tendDateTimeEnd = QDateTime::fromMSecsSinceEpoch(obj.m_TEnd * 1000);
+                auto tendDateTimeEnd = DateUtils::dateTime(obj.m_TEnd);
-                //        QDebug << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
                 d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
                 return d;
             }
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(SQPDATETIME_REGISTRY, SqpDateTime)
             #endif // SCIQLOP_SQPDATETIME_H

core/src/Variable/VariableController.cpp 0 -1

             #include <Variable/Variable.h>
             #include <Variable/VariableCacheController.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Time/TimeController.h>
-            #include <QDateTime>
             #include <QMutex>
             #include <QThread>
             #include <QUuid>
             #include <QtCore/QItemSelectionModel>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
                           m_VariableCacheController{std::make_unique<VariableCacheController>()}
                 {
                 }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheController> m_VariableCacheController;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
                 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
                 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
                         &VariableController::onAbortProgressRequested);
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
             QItemSelectionModel *VariableController::variableSelectionModel() noexcept
             {
                 return impl->m_VariableSelectionModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
                     return;
                 }
                 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
                 // make some treatments before the deletion
                 emit variableAboutToBeDeleted(variable);
                 // Deletes identifier
                 impl->m_VariableToIdentifierMap.erase(variable);
                 // Deletes provider
                 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
                 qCDebug(LOG_VariableController())
                     << tr("Number of providers deleted for variable %1: %2")
                            .arg(variable->name(), QString::number(nbProvidersDeleted));
                 // Clears cache
                 impl->m_VariableCacheController->clear(variable);
                 // Deletes from model
                 impl->m_VariableModel->deleteVariable(variable);
             }
             void VariableController::deleteVariables(
                 const QVector<std::shared_ptr<Variable> > &variables) noexcept
             {
                 for (auto variable : qAsConst(variables)) {
                     deleteVariable(variable);
                 }
             }
             void VariableController::abortProgress(std::shared_ptr<Variable> variable)
             {
             }
             void VariableController::createVariable(const QString &name, const QVariantHash &metadata,
                                                     std::shared_ptr<IDataProvider> provider) noexcept
             {
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return;
                 }
                 auto dateTime = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime, metadata)) {
                     auto identifier = QUuid::createUuid();
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     impl->m_VariableToIdentifierMap[newVariable] = identifier;
                     auto addDateTimeAcquired = [ this, varW = std::weak_ptr<Variable>{newVariable} ](
                         QUuid identifier, auto dataSeriesAcquired, auto dateTimeToPutInCache)
                     {
                         if (auto variable = varW.lock()) {
                             auto varIdentifier = impl->m_VariableToIdentifierMap.at(variable);
                             if (varIdentifier == identifier) {
                                 impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
                                 variable->setDataSeries(dataSeriesAcquired);
                                 emit variable->updated();
                             }
                         }
                     };
                     connect(provider.get(), &IDataProvider::dataProvided, addDateTimeAcquired);
                     connect(provider.get(), &IDataProvider::dataProvidedProgress, this,
                             &VariableController::onVariableRetrieveDataInProgress);
                     this->onRequestDataLoading(newVariable, dateTime);
                 }
             }
             void VariableController::onDateTimeOnSelection(const SqpDateTime &dateTime)
             {
                 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
                                                   << QThread::currentThread()->objectName();
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
                         selectedVariable->setDateTime(dateTime);
                         this->onRequestDataLoading(selectedVariable, dateTime);
                         // notify that rescale operation has to be done
                         emit rangeChanged(selectedVariable, dateTime);
                     }
                 }
             }
             void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
             {
                 auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
                 auto end = impl->m_VariableToIdentifierMap.cend();
                 auto it = std::find_if(impl->m_VariableToIdentifierMap.cbegin(), end, findReply);
                 if (it != end) {
                     impl->m_VariableModel->setDataProgress(it->first, progress);
                 }
             }
             void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
             {
                 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"
                                                   << QThread::currentThread()->objectName();
                 auto it = impl->m_VariableToIdentifierMap.find(variable);
                 if (it != impl->m_VariableToIdentifierMap.cend()) {
                     impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);
                 }
                 else {
                     qCWarning(LOG_VariableController())
                         << tr("Aborting progression of inexistant variable detected !!!")
                         << QThread::currentThread()->objectName();
                 }
             }
             void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
                                                           const SqpDateTime &dateTime)
             {
                 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
                                                   << QThread::currentThread()->objectName();
                 // 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) {
                     auto dateTimeListNotInCache
                         = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
                     if (!dateTimeListNotInCache.empty()) {
                         // Ask the provider for each data on the dateTimeListNotInCache
                         auto identifier = impl->m_VariableToIdentifierMap.at(variable);
                         impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
                             identifier,
                             DataProviderParameters{std::move(dateTimeListNotInCache), variable->metadata()});
                     }
                     else {
                         emit variable->updated();
                     }
                 }
                 else {
                     qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
                 }
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

core/src/Variable/VariableModel.cpp +4 -3

             #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
+            #include <Common/DateUtils.h>
             #include <Data/IDataSeries.h>
-            #include <QDateTime>
             #include <QSize>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto TSTART_COLUMN = 1;
             const auto TEND_COLUMN = 2;
             const auto NB_COLUMNS = 3;
             // Column properties
             const auto DEFAULT_HEIGHT = 25;
             const auto DEFAULT_WIDTH = 100;
             struct ColumnProperties {
                 ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
                                  int height = DEFAULT_HEIGHT)
                         : m_Name{name}, m_Width{width}, m_Height{height}
                 {
                 }
                 QString m_Name;
                 int m_Width;
                 int m_Height;
             };
             const auto COLUMN_PROPERTIES
                 = QHash<int, ColumnProperties>{{NAME_COLUMN, {QObject::tr("Name")}},
                                                {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
                                                {TEND_COLUMN, {QObject::tr("tEnd"), 180}}};
             /// Format for datetimes
             const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
             } // namespace
             struct VariableModel::VariableModelPrivate {
                 /// Variables created in SciQlop
                 std::vector<std::shared_ptr<Variable> > m_Variables;
                 std::unordered_map<std::shared_ptr<Variable>, double> m_VariableToProgress;
                 /// Return the row index of the variable. -1 if it's not found
                 int indexOfVariable(Variable *variable) const noexcept;
             };
             VariableModel::VariableModel(QObject *parent)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
             }
             std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
                                                                     const SqpDateTime &dateTime,
                                                                     const QVariantHash &metadata) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
                 auto variable = std::make_shared<Variable>(name, dateTime, metadata);
                 impl->m_Variables.push_back(variable);
                 connect(variable.get(), &Variable::updated, this, &VariableModel::onVariableUpdated);
                 endInsertRows();
                 return variable;
             }
             void VariableModel::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_Variable()) << "Can't delete a null variable from the model";
                     return;
                 }
                 // Finds variable in the model
                 auto begin = impl->m_Variables.cbegin();
                 auto end = impl->m_Variables.cend();
                 auto it = std::find(begin, end, variable);
                 if (it != end) {
                     auto removeIndex = std::distance(begin, it);
                     // Deletes variable
                     beginRemoveRows({}, removeIndex, removeIndex);
                     impl->m_Variables.erase(it);
                     endRemoveRows();
                 }
                 else {
                     qCritical(LOG_VariableModel())
                         << tr("Can't delete variable %1 from the model: the variable is not in the model")
                                .arg(variable->name());
                 }
                 // Removes variable from progress map
                 impl->m_VariableToProgress.erase(variable);
             }
             std::shared_ptr<Variable> VariableModel::variable(int index) const
             {
                 return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
             }
             void VariableModel::setDataProgress(std::shared_ptr<Variable> variable, double progress)
             {
                 if (progress > 0.0) {
                     impl->m_VariableToProgress[variable] = progress;
                 }
                 else {
                     impl->m_VariableToProgress.erase(variable);
                 }
                 auto modelIndex = createIndex(impl->indexOfVariable(variable.get()), NAME_COLUMN);
                 emit dataChanged(modelIndex, modelIndex);
             }
             int VariableModel::columnCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return NB_COLUMNS;
             }
             int VariableModel::rowCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return impl->m_Variables.size();
             }
             QVariant VariableModel::data(const QModelIndex &index, int role) const
             {
                 if (!index.isValid()) {
                     return QVariant{};
                 }
                 if (index.row() < 0 || index.row() >= rowCount()) {
                     return QVariant{};
                 }
                 if (role == Qt::DisplayRole) {
                     if (auto variable = impl->m_Variables.at(index.row()).get()) {
                         /// Lambda function that builds the variant to return for a time value
-                        auto dateTimeVariant = [](double time) {
+                        auto dateTimeVariant = [](double secs) {
-                            auto dateTime = QDateTime::fromMSecsSinceEpoch(time * 1000.);
+                            auto dateTime = DateUtils::dateTime(secs);
                             return dateTime.toString(DATETIME_FORMAT);
                         };
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case TSTART_COLUMN:
                                 return dateTimeVariant(variable->dateTime().m_TStart);
                             case TEND_COLUMN:
                                 return dateTimeVariant(variable->dateTime().m_TEnd);
                             default:
                                 // No action
                                 break;
                         }
                         qWarning(LOG_VariableModel())
                             << tr("Can't get data (unknown column %1)").arg(index.column());
                     }
                     else {
                         qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
                     }
                 }
                 else if (role == VariableRoles::ProgressRole) {
                     if (auto variable = impl->m_Variables.at(index.row())) {
                         auto it = impl->m_VariableToProgress.find(variable);
                         if (it != impl->m_VariableToProgress.cend()) {
                             return it->second;
                         }
                     }
                 }
                 return QVariant{};
             }
             QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
                     return QVariant{};
                 }
                 if (orientation == Qt::Horizontal) {
                     auto propertiesIt = COLUMN_PROPERTIES.find(section);
                     if (propertiesIt != COLUMN_PROPERTIES.cend()) {
                         // Role is either DisplayRole or SizeHintRole
                         return (role == Qt::DisplayRole)
                                    ? QVariant{propertiesIt->m_Name}
                                    : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
                     }
                     else {
                         qWarning(LOG_VariableModel())
                             << tr("Can't get header data (unknown column %1)").arg(section);
                     }
                 }
                 return QVariant{};
             }
             void VariableModel::abortProgress(const QModelIndex &index)
             {
                 if (auto variable = impl->m_Variables.at(index.row())) {
                     emit abortProgessRequested(variable);
                 }
             }
             void VariableModel::onVariableUpdated() noexcept
             {
                 // Finds variable that has been updated in the model
                 if (auto updatedVariable = dynamic_cast<Variable *>(sender())) {
                     auto updatedVariableIndex = impl->indexOfVariable(updatedVariable);
                     if (updatedVariableIndex > -1) {
                         emit dataChanged(createIndex(updatedVariableIndex, 0),
                                          createIndex(updatedVariableIndex, columnCount() - 1));
                     }
                 }
             }
             int VariableModel::VariableModelPrivate::indexOfVariable(Variable *variable) const noexcept
             {
                 auto begin = std::cbegin(m_Variables);
                 auto end = std::cend(m_Variables);
                 auto it
                     = std::find_if(begin, end, [variable](const auto &var) { return var.get() == variable; });
                 if (it != end) {
                     // Gets the index of the variable in the model: we assume here that views have the same
                     // order as the model
                     return std::distance(begin, it);
                 }
                 else {
                     return -1;
                 }
             }

gui/src/TimeWidget/TimeWidget.cpp +11 -9

             #include "TimeWidget/TimeWidget.h"
             #include "ui_TimeWidget.h"
+            #include <Common/DateUtils.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             TimeWidget::TimeWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::TimeWidget}
             {
                 ui->setupUi(this);
                 ui->applyToolButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_DialogApplyButton));
                 // Connection
                 connect(ui->startDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,
                         &TimeWidget::onTimeUpdateRequested);
                 connect(ui->endDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,
                         &TimeWidget::onTimeUpdateRequested);
                 connect(ui->applyToolButton, &QToolButton::clicked, &sqpApp->timeController(),
                         &TimeController::onTimeNotify);
                 // Initialisation
-                ui->startDateTimeEdit->setDateTime(
+                auto endDateTime = QDateTime::currentDateTimeUtc();
-                    QDateTime::currentDateTime().addSecs(-3600)); // one hour berefore
+                auto startDateTime = endDateTime.addSecs(-3600); // one hour before
-                ui->endDateTimeEdit->setDateTime(QDateTime::currentDateTime());
+                ui->startDateTimeEdit->setDateTime(startDateTime);
+                ui->endDateTimeEdit->setDateTime(endDateTime);
+                auto dateTime = SqpDateTime{DateUtils::secondsSinceEpoch(startDateTime),
+                                            DateUtils::secondsSinceEpoch(endDateTime)};
-                auto dateTime
-                    = SqpDateTime{QDateTime::currentDateTime().addSecs(-3600).toMSecsSinceEpoch() / 1000.0,
-                                  QDateTime::currentDateTime().toMSecsSinceEpoch() / 1000.0};
                 sqpApp->timeController().onTimeToUpdate(dateTime);
             }
             TimeWidget::~TimeWidget()
             {
                 delete ui;
             }
             void TimeWidget::onTimeUpdateRequested()
             {
-                auto dateTime = SqpDateTime{
+                auto dateTime = SqpDateTime{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
-                    static_cast<double>(ui->startDateTimeEdit->dateTime().toMSecsSinceEpoch() / 1000.),
+                                            DateUtils::secondsSinceEpoch(ui->endDateTimeEdit->dateTime())};
-                    static_cast<double>(ui->endDateTimeEdit->dateTime().toMSecsSinceEpoch()) / 1000.};
                 emit timeUpdated(std::move(dateTime));
             }

gui/src/Visualization/VisualizationGraphHelper.cpp +1 0

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarSeries.h>
             #include <Variable/Variable.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             namespace {
             class SqpDataContainer : public QCPGraphDataContainer {
             public:
                 void appendGraphData(const QCPGraphData &data) { mData.append(data); }
             };
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
             /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
             /// non-time data
             QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
             {
                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
+                    dateTicker->setDateTimeSpec(Qt::UTC);
                     return dateTicker;
                 }
                 else {
                     // default ticker
                     return QSharedPointer<QCPAxisTicker>::create();
                 }
             }
             void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSeries,
                                   const SqpDateTime &dateTime)
             {
                 qCDebug(LOG_VisualizationGraphHelper()) << "TORM: updateScalarData"
                                                         << QThread::currentThread()->objectName();
                 if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
                     scalarSeries.lockRead();
                     {
                         const auto &xData = scalarSeries.xAxisData()->cdata();
                         const auto &valuesData = scalarSeries.valuesData()->cdata();
                         auto xDataBegin = xData.cbegin();
                         auto xDataEnd = xData.cend();
                         qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache"
                                                                << xData.count();
                         auto sqpDataContainer = QSharedPointer<SqpDataContainer>::create();
                         qcpGraph->setData(sqpDataContainer);
                         auto lowerIt = std::lower_bound(xDataBegin, xDataEnd, dateTime.m_TStart);
                         auto upperIt = std::upper_bound(xDataBegin, xDataEnd, dateTime.m_TEnd);
                         auto distance = std::distance(xDataBegin, lowerIt);
                         auto valuesDataIt = valuesData.cbegin() + distance;
                         for (auto xAxisDataIt = lowerIt; xAxisDataIt != upperIt;
                              ++xAxisDataIt, ++valuesDataIt) {
                             sqpDataContainer->appendGraphData(QCPGraphData(*xAxisDataIt, *valuesDataIt));
                         }
                         qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed"
                                                                << sqpDataContainer->size();
                     }
                     scalarSeries.unlock();
                     // Display all data
                     component->parentPlot()->replot();
                 }
                 else {
                     /// @todo DEBUG
                 }
             }
             QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot,
                                                               const SqpDateTime &dateTime)
             {
                 auto component = plot.addGraph();
                 if (component) {
                     //        // 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
                     auto setAxisProperties = [](auto axis, const auto &unit) {
                         // label (unit name)
                         axis->setLabel(unit.m_Name);
                         // ticker (depending on the type of unit)
                         axis->setTicker(axisTicker(unit.m_TimeUnit));
                     };
                     setAxisProperties(plot.xAxis, scalarSeries.xAxisUnit());
                     setAxisProperties(plot.yAxis, scalarSeries.valuesUnit());
                     // Display all data
                     component->rescaleAxes();
                     plot.replot();
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph for the scalar series");
                 }
                 return component;
             }
             } // namespace
             QVector<QCPAbstractPlottable *> VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
                                                                              QCustomPlot &plot) noexcept
             {
                 auto result = QVector<QCPAbstractPlottable *>{};
                 if (variable) {
                     // 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, variable->dateTime()));
                     }
                     else {
                         qCDebug(LOG_VisualizationGraphHelper())
                             << QObject::tr("Can't create graph plottables : unmanaged data series type");
                     }
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                 }
                 return result;
             }
             void VisualizationGraphHelper::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_VisualizationGraphHelper()) << QObject::tr(
                             "Can't update Data of a scalarSeries because there is not only one component "
                             "associated");
                     }
                 }
                 else {
                     /// @todo DEBUG
                 }
             }

gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp +8 -3

             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/qcustomplot.h"
+            #include <Common/DateUtils.h>
             namespace {
             const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");
             const auto TEXT_TRACER_FORMAT = QStringLiteral("key: %1\nvalue: %2");
             /// Timeout after which a tracer is displayed
             const auto TRACER_TIMEOUT = 500;
             /// Formats a data value according to the axis on which it is present
             QString formatValue(double value, const QCPAxis &axis)
             {
                 // If the axis is a time axis, formats the value as a date
-                return qSharedPointerDynamicCast<QCPAxisTickerDateTime>(axis.ticker())
+                if (auto axisTicker = qSharedPointerDynamicCast<QCPAxisTickerDateTime>(axis.ticker())) {
-                           ? QCPAxisTickerDateTime::keyToDateTime(value).toString(DATETIME_FORMAT)
+                    return DateUtils::dateTime(value, axisTicker->dateTimeSpec()).toString(DATETIME_FORMAT);
-                           : QString::number(value);
+                else {
+                    return QString::number(value);
+                }
             }
             void initPointTracerStyle(QCPItemTracer &tracer) noexcept
             {
                 tracer.setInterpolating(false);
                 tracer.setStyle(QCPItemTracer::tsPlus);
                 tracer.setPen(QPen(Qt::black));
                 tracer.setBrush(Qt::black);
                 tracer.setSize(10);
             }
             void initTextTracerStyle(QCPItemText &tracer) noexcept
             {
                 tracer.setPen(QPen{Qt::gray});
                 tracer.setBrush(Qt::white);
                 tracer.setPadding(QMargins{6, 6, 6, 6});
                 tracer.setPositionAlignment(Qt::AlignTop | Qt::AlignLeft);
                 tracer.setTextAlignment(Qt::AlignLeft);
             }
             } // namespace
             struct VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegatePrivate {
                 explicit VisualizationGraphRenderingDelegatePrivate(QCustomPlot &plot)
                         : m_Plot{plot},
                           m_PointTracer{new QCPItemTracer{&plot}},
                           m_TextTracer{new QCPItemText{&plot}},
                           m_TracerTimer{}
                 {
                     initPointTracerStyle(*m_PointTracer);
                     initTextTracerStyle(*m_TextTracer);
                     m_TracerTimer.setInterval(TRACER_TIMEOUT);
                     m_TracerTimer.setSingleShot(true);
                 }
                 QCustomPlot &m_Plot;
                 QCPItemTracer *m_PointTracer;
                 QCPItemText *m_TextTracer;
                 QTimer m_TracerTimer;
             };
             VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegate(QCustomPlot &plot)
                     : impl{spimpl::make_unique_impl<VisualizationGraphRenderingDelegatePrivate>(plot)}
             {
             }
             void VisualizationGraphRenderingDelegate::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Cancels pending refresh
                 impl->m_TracerTimer.disconnect();
                 auto showTracers = [ eventPos = event->pos(), this ]()
                 {
                     // Lambda function to display a tracer
                     auto displayTracer = [this](auto &tracer) {
                         // Tracer is set on top of the plot's main layer
                         tracer.setLayer(impl->m_Plot.layer("main"));
                         tracer.setVisible(true);
                         impl->m_Plot.replot();
                     };
                     // Reinits tracers
                     impl->m_PointTracer->setGraph(nullptr);
                     impl->m_PointTracer->setVisible(false);
                     impl->m_TextTracer->setVisible(false);
                     impl->m_Plot.replot();
                     // Gets the graph under the mouse position
                     if (auto graph = qobject_cast<QCPGraph *>(impl->m_Plot.plottableAt(eventPos))) {
                         auto mouseKey = graph->keyAxis()->pixelToCoord(eventPos.x());
                         auto graphData = graph->data();
                         // Gets the closest data point to the mouse
                         auto graphDataIt = graphData->findBegin(mouseKey);
                         if (graphDataIt != graphData->constEnd()) {
                             auto key = formatValue(graphDataIt->key, *graph->keyAxis());
                             auto value = formatValue(graphDataIt->value, *graph->valueAxis());
                             impl->m_TextTracer->setText(TEXT_TRACER_FORMAT.arg(key, value));
                             // Displays point tracer
                             impl->m_PointTracer->setGraph(graph);
                             impl->m_PointTracer->setGraphKey(mouseKey);
                             displayTracer(*impl->m_PointTracer);
                             // Displays text tracer
                             auto tracerPosition = impl->m_TextTracer->position;
                             tracerPosition->setAxes(graph->keyAxis(), graph->valueAxis());
                             tracerPosition->setCoords(impl->m_PointTracer->position->key(),
                                                       impl->m_PointTracer->position->value());
                             displayTracer(*impl->m_TextTracer);
                         }
                     }
                 };
                 // Starts the timer to display tracers at timeout
                 QObject::connect(&impl->m_TracerTimer, &QTimer::timeout, showTracers);
                 impl->m_TracerTimer.start();
             }

gui/ui/TimeWidget/TimeWidget.ui +6 0

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>TimeWidget</class>
              <widget class="QWidget" name="TimeWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>716</width>
                 <height>48</height>
                </rect>
               </property>
               <property name="sizePolicy">
                <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QHBoxLayout" name="horizontalLayout_2">
                <item>
                 <widget class="QLabel" name="label">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <property name="text">
                   <string>TStart :</string>
                  </property>
                 </widget>
                </item>
                <item>
                 <widget class="QDateTimeEdit" name="startDateTimeEdit">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <property name="displayFormat">
                   <string>dd/MM/yyyy HH:mm:ss:zzz</string>
                  </property>
                  <property name="calendarPopup">
                   <bool>true</bool>
                  </property>
+                 <property name="timeSpec">
+                  <enum>Qt::UTC</enum>
+                 </property>
                 </widget>
                </item>
                <item>
                 <widget class="QLabel" name="label_2">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <property name="text">
                   <string>TEnd :</string>
                  </property>
                 </widget>
                </item>
                <item>
                 <widget class="QDateTimeEdit" name="endDateTimeEdit">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <property name="displayFormat">
                   <string>dd/MM/yyyy HH:mm:ss:zzz</string>
                  </property>
                  <property name="calendarPopup">
                   <bool>true</bool>
                  </property>
+                 <property name="timeSpec">
+                  <enum>Qt::UTC</enum>
+                 </property>
                 </widget>
                </item>
                <item>
                 <widget class="QToolButton" name="applyToolButton">
                  <property name="text">
                   <string>...</string>
                  </property>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources/>
              <connections/>
             </ui>

plugins/amda/src/AmdaProvider.cpp +2 -1

             #include "AmdaProvider.h"
             #include "AmdaDefs.h"
             #include "AmdaResultParser.h"
+            #include <Common/DateUtils.h>
             #include <Data/DataProviderParameters.h>
             #include <Network/NetworkController.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <QNetworkAccessManager>
             #include <QNetworkReply>
             #include <QTemporaryFile>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
             namespace {
             /// URL format for a request on AMDA server. The parameters are as follows:
             /// - %1: start date
             /// - %2: end date
             /// - %3: parameter id
             const auto AMDA_URL_FORMAT = QStringLiteral(
                 "http://amda.irap.omp.eu/php/rest/"
                 "getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&outputFormat=ASCII&"
                 "timeFormat=ISO8601&gzip=0");
             /// Dates format passed in the URL (e.g 2013-09-23T09:00)
             const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
             /// Formats a time to a date that can be passed in URL
             QString dateFormat(double sqpDateTime) noexcept
             {
-                auto dateTime = QDateTime::fromMSecsSinceEpoch(sqpDateTime * 1000.);
+                auto dateTime = DateUtils::dateTime(sqpDateTime);
                 return dateTime.toString(AMDA_TIME_FORMAT);
             }
             } // namespace
             AmdaProvider::AmdaProvider()
             {
                 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     connect(this, SIGNAL(requestConstructed(QNetworkRequest, QUuid,
                                                             std::function<void(QNetworkReply *, QUuid)>)),
                             &networkController,
                             SLOT(onProcessRequested(QNetworkRequest, QUuid,
                                                     std::function<void(QNetworkReply *, QUuid)>)));
                     connect(&sqpApp->networkController(), SIGNAL(replyDownloadProgress(QUuid, double)), this,
                             SIGNAL(dataProvidedProgress(QUuid, double)));
                 }
             }
             void AmdaProvider::requestDataLoading(QUuid token, const DataProviderParameters &parameters)
             {
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 const auto data = parameters.m_Data;
                 for (const auto &dateTime : qAsConst(times)) {
                     retrieveData(token, dateTime, data);
                 }
             }
             void AmdaProvider::requestDataAborting(QUuid identifier)
             {
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     networkController.onReplyCanceled(identifier);
                 }
             }
             void AmdaProvider::retrieveData(QUuid token, const SqpDateTime &dateTime, const QVariantHash &data)
             {
                 // Retrieves product ID from data: if the value is invalid, no request is made
                 auto productId = data.value(AMDA_XML_ID_KEY).toString();
                 if (productId.isNull()) {
                     qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
                     return;
                 }
                 qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData") << dateTime;
                 // /////////// //
                 // Creates URL //
                 // /////////// //
                 auto startDate = dateFormat(dateTime.m_TStart);
                 auto endDate = dateFormat(dateTime.m_TEnd);
                 auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
                 qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData url:") << url;
                 auto tempFile = std::make_shared<QTemporaryFile>();
                 // LAMBDA
                 auto httpDownloadFinished
                     = [this, dateTime, tempFile, token](QNetworkReply *reply, QUuid dataId) noexcept {
                           Q_UNUSED(dataId);
                           // Don't do anything if the reply was abort
                           if (reply->error() != QNetworkReply::OperationCanceledError) {
                               if (tempFile) {
                                   auto replyReadAll = reply->readAll();
                                   if (!replyReadAll.isEmpty()) {
                                       tempFile->write(replyReadAll);
                                   }
                                   tempFile->close();
                                   // Parse results file
                                   if (auto dataSeries = AmdaResultParser::readTxt(tempFile->fileName())) {
                                       emit dataProvided(token, dataSeries, dateTime);
                                   }
                                   else {
                                       /// @todo ALX : debug
                                   }
                               }
                           }
                       };
                 auto httpFinishedLambda
                     = [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
                           // Don't do anything if the reply was abort
                           if (reply->error() != QNetworkReply::OperationCanceledError) {
                               auto downloadFileUrl = QUrl{QString{reply->readAll()}};
                               qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData downloadFileUrl:")
                                                          << downloadFileUrl;
                               // Executes request for downloading file //
                               // Creates destination file
                               if (tempFile->open()) {
                                   // Executes request
                                   emit requestConstructed(QNetworkRequest{downloadFileUrl}, dataId,
                                                           httpDownloadFinished);
                               }
                           }
                       };
                 // //////////////// //
                 // Executes request //
                 // //////////////// //
                 emit requestConstructed(QNetworkRequest{url}, token, httpFinishedLambda);
             }

plugins/amda/src/AmdaResultParser.cpp +19 -12

             #include "AmdaResultParser.h"
+            #include <Common/DateUtils.h>
             #include <Data/ScalarSeries.h>
             #include <QDateTime>
             #include <QFile>
             #include <QRegularExpression>
             #include <cmath>
             Q_LOGGING_CATEGORY(LOG_AmdaResultParser, "AmdaResultParser")
             namespace {
             /// Message in result file when the file was not found on server
             const auto FILE_NOT_FOUND_MESSAGE = QStringLiteral("Not Found");
             /// Format for dates in result files
             const auto DATE_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss.zzz");
             /// Separator between values in a result line
             const auto RESULT_LINE_SEPARATOR = QRegularExpression{QStringLiteral("\\s+")};
             /// Regex to find unit in a line. Examples of valid lines:
             /// ... - Units : nT - ...
             /// ... -Units:nT- ...
             /// ... -Units:   m²- ...
             /// ... - Units : m/s - ...
             const auto UNIT_REGEX = QRegularExpression{QStringLiteral("-\\s*Units\\s*:\\s*(.+?)\\s*-")};
             /// Converts a string date to a double date
             /// @return a double that represents the date in seconds, NaN if the string date can't be converted
             double doubleDate(const QString &stringDate) noexcept
             {
                 auto dateTime = QDateTime::fromString(stringDate, DATE_FORMAT);
-                return dateTime.isValid() ? (dateTime.toMSecsSinceEpoch() / 1000.)
+                dateTime.setTimeSpec(Qt::UTC);
+                return dateTime.isValid() ? DateUtils::secondsSinceEpoch(dateTime)
                                           : std::numeric_limits<double>::quiet_NaN();
             }
+            /// Checks if a line is a comment line
+            bool isCommentLine(const QString &line)
+            {
+                return line.startsWith("#");
+            }
             /**
              * Reads stream to retrieve x-axis unit
              * @param stream the stream to read
              * @return the unit that has been read in the stream, a default unit (time unit with no label) if an
              * error occured during reading
              */
             Unit readXAxisUnit(QTextStream &stream)
             {
                 QString line{};
-                if (stream.readLineInto(&line)) {
+                // Searches unit in the comment lines
+                while (stream.readLineInto(&line) && isCommentLine(line)) {
                     auto match = UNIT_REGEX.match(line);
                     if (match.hasMatch()) {
                         return Unit{match.captured(1), true};
                     }
-                    else {
-                        qCWarning(LOG_AmdaResultParser())
-                            << QObject::tr("Can't read unit: invalid line %1").arg(line);
-                else {
-                    qCWarning(LOG_AmdaResultParser()) << QObject::tr("Can't read unit: end of file");
                 }
+                qCWarning(LOG_AmdaResultParser()) << QObject::tr("The unit could not be found in the file");
                 // Error cases
                 return Unit{{}, true};
             }
             /**
              * Reads stream to retrieve results
              * @param stream the stream to read
              * @return the pair of vectors x-axis data/values data that has been read in the stream
              */
             QPair<QVector<double>, QVector<double> > readResults(QTextStream &stream)
             {
                 auto xData = QVector<double>{};
                 auto valuesData = QVector<double>{};
                 QString line{};
                 while (stream.readLineInto(&line)) {
+                    // Ignore comment lines
+                    if (!isCommentLine(line)) {
                         auto lineData = line.split(RESULT_LINE_SEPARATOR, QString::SkipEmptyParts);
                         if (lineData.size() == 2) {
                             // X : the data is converted from date to double (in secs)
                             auto x = doubleDate(lineData.at(0));
                             // Value
                             bool valueOk;
                             auto value = lineData.at(1).toDouble(&valueOk);
                             // Adds result only if x and value are valid
                             if (!std::isnan(x) && !std::isnan(value) && valueOk) {
                                 xData.push_back(x);
                                 valuesData.push_back(value);
                             }
                             else {
                                 qCWarning(LOG_AmdaResultParser())
                                     << QObject::tr(
                                            "Can't retrieve results from line %1: x and/or value are invalid")
                                            .arg(line);
                             }
                         }
                         else {
                             qCWarning(LOG_AmdaResultParser())
                                 << QObject::tr("Can't retrieve results from line %1: invalid line").arg(line);
                         }
                     }
+                }
                 return qMakePair(std::move(xData), std::move(valuesData));
             }
             } // namespace
             std::shared_ptr<IDataSeries> AmdaResultParser::readTxt(const QString &filePath) noexcept
             {
                 QFile file{filePath};
                 if (!file.open(QFile::ReadOnly | QIODevice::Text)) {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data from file %1: %2")
                                .arg(filePath, file.errorString());
                     return nullptr;
                 }
                 QTextStream stream{&file};
                 // Checks if the file was found on the server
                 auto firstLine = stream.readLine();
                 if (firstLine.compare(FILE_NOT_FOUND_MESSAGE) == 0) {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data from file %1: file was not found on server")
                                .arg(filePath);
                     return nullptr;
                 }
-                // Ignore comments lines
-                stream.readLine();
                 // Reads x-axis unit
+                stream.seek(0); // returns to the beginning of the file
                 auto xAxisUnit = readXAxisUnit(stream);
                 // Reads results
+                stream.seek(0); // returns to the beginning of the file
                 auto results = readResults(stream);
                 return std::make_shared<ScalarSeries>(std::move(results.first), std::move(results.second),
                                                       xAxisUnit, Unit{});
             }

plugins/amda/tests/TestAmdaResultParser.cpp +1 -1

             #include "AmdaResultParser.h"
             #include <Data/ScalarSeries.h>
             #include <QObject>
             #include <QtTest>
             namespace {
             /// Path for the tests
             const auto TESTS_RESOURCES_PATH
                 = QFileInfo{QString{AMDA_TESTS_RESOURCES_DIR}, "TestAmdaResultParser"}.absoluteFilePath();
             QString inputFilePath(const QString &inputFileName)
             {
                 return QFileInfo{TESTS_RESOURCES_PATH, inputFileName}.absoluteFilePath();
             }
             struct ExpectedResults {
                 explicit ExpectedResults() = default;
                 /// Ctor with QVector<QDateTime> as x-axis data. Datetimes are converted to doubles
                 explicit ExpectedResults(Unit xAxisUnit, Unit valuesUnit, const QVector<QDateTime> &xAxisData,
                                          QVector<double> valuesData)
                         : m_ParsingOK{true},
                           m_XAxisUnit{xAxisUnit},
                           m_ValuesUnit{valuesUnit},
                           m_XAxisData{},
                           m_ValuesData{std::move(valuesData)}
                 {
                     // Converts QVector<QDateTime> to QVector<double>
                     std::transform(xAxisData.cbegin(), xAxisData.cend(), std::back_inserter(m_XAxisData),
                                    [](const auto &dateTime) { return dateTime.toMSecsSinceEpoch() / 1000.; });
                 }
                 /**
                  * Validates a DataSeries compared to the expected results
                  * @param results the DataSeries to validate
                  */
                 void validate(std::shared_ptr<IDataSeries> results)
                 {
                     if (m_ParsingOK) {
                         auto scalarSeries = dynamic_cast<ScalarSeries *>(results.get());
                         QVERIFY(scalarSeries != nullptr);
                         // Checks units
                         QVERIFY(scalarSeries->xAxisUnit() == m_XAxisUnit);
                         QVERIFY(scalarSeries->valuesUnit() == m_ValuesUnit);
                         // Checks values
                         QVERIFY(scalarSeries->xAxisData()->data() == m_XAxisData);
                         QVERIFY(scalarSeries->valuesData()->data() == m_ValuesData);
                     }
                     else {
                         QVERIFY(results == nullptr);
                     }
                 }
                 // Parsing was successfully completed
                 bool m_ParsingOK{false};
                 // Expected x-axis unit
                 Unit m_XAxisUnit{};
                 // Expected values unit
                 Unit m_ValuesUnit{};
                 // Expected x-axis data
                 QVector<double> m_XAxisData{};
                 // Expected values data
                 QVector<double> m_ValuesData{};
             };
             } // namespace
             Q_DECLARE_METATYPE(ExpectedResults)
             class TestAmdaResultParser : public QObject {
                 Q_OBJECT
             private slots:
                 /// Input test data
                 /// @sa testTxtJson()
                 void testReadTxt_data();
                 /// Tests parsing of a TXT file
                 void testReadTxt();
             };
             void TestAmdaResultParser::testReadTxt_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 // Name of TXT file to read
                 QTest::addColumn<QString>("inputFileName");
                 // Expected results
                 QTest::addColumn<ExpectedResults>("expectedResults");
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 auto dateTime = [](int year, int month, int day, int hours, int minutes, int seconds) {
-                    return QDateTime{{year, month, day}, {hours, minutes, seconds}};
+                    return QDateTime{{year, month, day}, {hours, minutes, seconds}, Qt::UTC};
                 };
                 // Valid file
                 QTest::newRow("Valid file")
                     << QStringLiteral("ValidScalar1.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                               dateTime(2013, 9, 23, 9, 2, 30), dateTime(2013, 9, 23, 9, 3, 30),
                                               dateTime(2013, 9, 23, 9, 4, 30), dateTime(2013, 9, 23, 9, 5, 30),
                                               dateTime(2013, 9, 23, 9, 6, 30), dateTime(2013, 9, 23, 9, 7, 30),
                                               dateTime(2013, 9, 23, 9, 8, 30), dateTime(2013, 9, 23, 9, 9, 30)},
                            QVector<double>{-2.83950, -2.71850, -2.52150, -2.57633, -2.58050, -2.48325, -2.63025,
                                            -2.55800, -2.43250, -2.42200}};
                 // Valid files but with some invalid lines (wrong unit, wrong values, etc.)
                 QTest::newRow("No unit file") << QStringLiteral("NoUnit.txt")
                                               << ExpectedResults{Unit{QStringLiteral(""), true}, Unit{},
                                                                  QVector<QDateTime>{}, QVector<double>{}};
                 QTest::newRow("Wrong unit file")
                     << QStringLiteral("WrongUnit.txt")
                     << ExpectedResults{Unit{QStringLiteral(""), true}, Unit{},
                                        QVector<QDateTime>{dateTime(2013, 9, 23, 9, 0, 30),
                                                           dateTime(2013, 9, 23, 9, 1, 30),
                                                           dateTime(2013, 9, 23, 9, 2, 30)},
                                        QVector<double>{-2.83950, -2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (date of first line is invalid")
                     << QStringLiteral("WrongDate.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (too many values for first line")
                     << QStringLiteral("TooManyValues.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (value of first line is invalid")
                     << QStringLiteral("WrongValue.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (value of first line is NaN")
                     << QStringLiteral("NaNValue.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 // Invalid files
                 QTest::newRow("Invalid file (unexisting file)") << QStringLiteral("UnexistingFile.txt")
                                                                 << ExpectedResults{};
                 QTest::newRow("Invalid file (file not found on server)") << QStringLiteral("FileNotFound.txt")
                                                                          << ExpectedResults{};
             }
             void TestAmdaResultParser::testReadTxt()
             {
                 QFETCH(QString, inputFileName);
                 QFETCH(ExpectedResults, expectedResults);
                 // Parses file
                 auto filePath = inputFilePath(inputFileName);
                 auto results = AmdaResultParser::readTxt(filePath);
                 // ///////////////// //
                 // Validates results //
                 // ///////////////// //
                 expectedResults.validate(results);
             }
             QTEST_MAIN(TestAmdaResultParser)
             #include "TestAmdaResultParser.moc"

plugins/mockplugin/src/CosinusProvider.cpp 0 -1

             #include "CosinusProvider.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <cmath>
-            #include <QDateTime>
             #include <QFuture>
             #include <QThread>
             #include <QtConcurrent/QtConcurrent>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
             std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid token, const SqpDateTime &dateTime)
             {
                 // TODO: Add Mutex
                 auto dataIndex = 0;
                 // Gets the timerange from the parameters
                 double freq = 100.0;
                 double start = std::ceil(dateTime.m_TStart * freq); // 100 htz
                 double end = std::floor(dateTime.m_TEnd * freq);    // 100 htz
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second)
                 auto dataCount = end - start;
                 auto xAxisData = QVector<double>{};
                 xAxisData.resize(dataCount);
                 auto valuesData = QVector<double>{};
                 valuesData.resize(dataCount);
                 int progress = 0;
                 auto progressEnd = dataCount;
                 for (auto time = start; time < end; ++time, ++dataIndex) {
                     auto it = m_VariableToEnableProvider.find(token);
                     if (it != m_VariableToEnableProvider.end() && it.value()) {
                         const auto timeOnFreq = time / freq;
                         xAxisData.replace(dataIndex, timeOnFreq);
                         valuesData.replace(dataIndex, std::cos(timeOnFreq));
                         // progression
                         int currentProgress = (time - start) * 100.0 / progressEnd;
                         if (currentProgress != progress) {
                             progress = currentProgress;
                             emit dataProvidedProgress(token, progress);
                         }
                     }
                     else {
                         if (!it.value()) {
                             qCDebug(LOG_CosinusProvider())
                                 << "CosinusProvider::retrieveData: ARRET De l'acquisition detecté"
                                 << end - time;
                         }
                     }
                 }
                 emit dataProvidedProgress(token, 0.0);
                 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                       Unit{QStringLiteral("t"), true}, Unit{});
             }
             void CosinusProvider::requestDataLoading(QUuid token, const DataProviderParameters &parameters)
             {
                 // TODO: Add Mutex
                 m_VariableToEnableProvider[token] = true;
                 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataLoading"
                                                << QThread::currentThread()->objectName();
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 for (const auto &dateTime : qAsConst(times)) {
                     if (m_VariableToEnableProvider[token]) {
                         auto scalarSeries = this->retrieveData(token, dateTime);
                         emit dataProvided(token, scalarSeries, dateTime);
                     }
                 }
             }
             void CosinusProvider::requestDataAborting(QUuid identifier)
             {
                 // TODO: Add Mutex
                 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << identifier
                                                << QThread::currentThread()->objectName();
                 auto it = m_VariableToEnableProvider.find(identifier);
                 if (it != m_VariableToEnableProvider.end()) {
                     it.value() = false;
                 }
                 else {
                     qCWarning(LOG_CosinusProvider())
                         << tr("Aborting progression of inexistant identifier detected !!!");
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages