GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r299:bc65aa8d09b9

Merge branch 'feature/DateTimeOfVariableAtInit' into develop

perrinel -

r299:bc65aa8d09b9

parent child

Context file:

r299:bc65aa8d09b9

core/include/Data/ArrayData.h +4 -4

                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
-                QVector<double> data() const noexcept
+                const QVector<double> &data() const noexcept
                 {
-                    return m_Data.at(0);
+                    return m_Data[0];
                 }
                 /**
                 // TODO Comment
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
-                void merge(ArrayData<1> *arrayData)
+                void merge(const ArrayData<1> &arrayData)
                 {
                     if (!m_Data.empty()) {
-                        m_Data[0] += arrayData->data();
+                        m_Data[0] += arrayData.data();
                     }
                 }

core/include/Data/DataSeries.h +2 -2

                 void merge(IDataSeries *dataSeries) override
                 {
                     if (auto dimDataSeries = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
-                        m_XAxisData->merge(dimDataSeries->xAxisData().get());
+                        m_XAxisData->merge(*dimDataSeries->xAxisData());
-                        m_ValuesData->merge(dimDataSeries->valuesData().get());
+                        m_ValuesData->merge(*dimDataSeries->valuesData());
                     }
                     else {
                         qCWarning(LOG_DataSeries())

core/include/Data/SqpDateTime.h +14 0

             #define SCIQLOP_SQPDATETIME_H
             #include <QObject>
+            #include <QDateTime>
+            #include <QDebug>
             /**
              * @brief The SqpDateTime struct holds the information of time parameters
              */
                 }
             };
+            inline QDebug operator<<(QDebug d, SqpDateTime obj)
+            {
+                auto tendDateTimeStart = QDateTime::fromMSecsSinceEpoch(obj.m_TStart * 1000);
+                auto tendDateTimeEnd = QDateTime::fromMSecsSinceEpoch(obj.m_TEnd * 1000);
+                //        QDebug << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
+                d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
+                return d;
+            }
             // Required for using shared_ptr in signals/slots
             Q_DECLARE_METATYPE(SqpDateTime)

core/include/Variable/Variable.h +1 -1

                 void onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             signals:
-                void dataCacheUpdated();
+                void updated();
             private:

core/include/Variable/VariableCacheController.h +7 0

             #include <Data/SqpDateTime.h>
+            #include <QLoggingCategory>
             #include <Common/spimpl.h>
             class Variable;
+            Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController)
             /// This class aims to store in the cache all of the dateTime already requested to the variable.
             class VariableCacheController : public QObject {
                 Q_OBJECT
                 QVector<SqpDateTime> dateCacheList(std::shared_ptr<Variable> variable) const noexcept;
+                void displayCache(std::shared_ptr<Variable> variable);
             private:
                 class VariableCacheControllerPrivate;
                 spimpl::unique_impl_ptr<VariableCacheControllerPrivate> impl;

core/include/Variable/VariableController.h +2 -3

                 void setTimeController(TimeController *timeController) noexcept;
-                /// Request the data loading of the variable whithin dateTime
-                void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
             signals:
                 /// Signal emitted when a variable has been created
                 void variableCreated(std::shared_ptr<Variable> variable);
             public slots:
+                /// Request the data loading of the variable whithin dateTime
+                void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
                 /**
                  * Creates a new variable and adds it to the model
                  * @param name the name of the new variable

core/src/Variable/Variable.cpp +1 -1

                 if (impl->m_DataSeries) {
                     impl->m_DataSeries->merge(dataSeries.get());
-                    emit dataCacheUpdated();
+                    emit updated();
                 }
             }

core/src/Variable/VariableCacheController.cpp +19 -6

             #include "Variable/Variable.h"
             #include <unordered_map>
+            Q_LOGGING_CATEGORY(LOG_VariableCacheController, "VariableCacheController")
             struct VariableCacheController::VariableCacheControllerPrivate {
                 std::unordered_map<std::shared_ptr<Variable>, QVector<SqpDateTime> >
                     // ts localised between to interval: let's localized te
                     addInCacheDataByEnd(dateTime, dateTimeList, notInCache, cacheIndex, currentTStart);
                 }
-                else if (dateTime.m_TStart < currentDateTimeI.m_TEnd) {
+                else if (currentTStart < currentDateTimeI.m_TEnd) {
-                    // ts not localised before the current interval: we need to look at the next interval
+                    if (dateTime.m_TEnd > currentDateTimeI.m_TEnd) {
-                    // We can assume now current tstart is the last interval tend, because data between them are
+                        // ts not localised before the current interval: we need to look at the next interval
-                    // in the cache
+                        // We can assume now current tstart is the last interval tend, because data between them
-                    addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex,
+                        // are
-                                          currentDateTimeI.m_TEnd);
+                        // in the cache
+                        addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex,
+                                              currentDateTimeI.m_TEnd);
+                    }
                 }
                 else {
                     // ts not localised before the current interval: we need to look at the next interval
                     addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex, currentTStart);
                 }
             }
+            void VariableCacheController::displayCache(std::shared_ptr<Variable> variable)
+            {
+                auto variableDateTimeList = impl->m_VariableToSqpDateTimeListMap.at(variable);
+                qCInfo(LOG_VariableCacheController()) << tr("VariableCacheController::displayCache")
+                                                      << variableDateTimeList;
+            }

core/src/Variable/VariableController.cpp +12 -19

             #include <Time/TimeController.h>
             #include <QDateTime>
-            #include <QElapsedTimer>
             #include <QMutex>
             #include <QThread>
             }
-            void VariableController::requestDataLoading(std::shared_ptr<Variable> variable,
+            void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
-                                                        const SqpDateTime &dateTime)
+                                                          const SqpDateTime &dateTime)
             {
                 // we want to load data of the variable for the dateTime.
                 // First we check if the cache contains some of them.
                 // For the other, we ask the provider to give them.
                 if (variable) {
-                    QElapsedTimer timer;
-                    timer.start();
-                    qCInfo(LOG_VariableController()) << "TORM: The slow s0 operation took" << timer.elapsed()
-                                                     << "milliseconds";
                     auto dateTimeListNotInCache
                         = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
-                    qCInfo(LOG_VariableController()) << "TORM: The slow s1 operation took" << timer.elapsed()
-                                                     << "milliseconds";
-                    // Ask the provider for each data on the dateTimeListNotInCache
+                    if (!dateTimeListNotInCache.empty()) {
-                    impl->m_VariableToProviderMap.at(variable)->requestDataLoading(dateTimeListNotInCache);
+                        // Ask the provider for each data on the dateTimeListNotInCache
+                        impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
-                    qCInfo(LOG_VariableController()) << "TORM: The slow s2 operation took" << timer.elapsed()
+                            std::move(dateTimeListNotInCache));
-                                                     << "milliseconds";
+                        // store in cache
+                        impl->m_VariableCacheController->addDateTime(variable, dateTime);
-                    // store in cache
-                    impl->m_VariableCacheController->addDateTime(variable, dateTime);
+                    else {
-                    qCInfo(LOG_VariableController()) << "TORM: The slow s3 operation took" << timer.elapsed()
+                        emit variable->updated();
-                                                     << "milliseconds";
                 }
                 else {
                     qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");

core/tests/Variable/TestVariableCacheController.cpp +10 0

@@ -241,6 +241,16 void TestVariableCacheController::testProvideNotInCacheDateTimeList()
241	notInCacheSqp = notInCach.at(1);	241	notInCacheSqp = notInCach.at(1);
242	QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));	242	QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
243	QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));	243	QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
		244
		245
		246	// 12th case ts0 < ts < te0
		247	ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 10, 0}};
		248	te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 50, 0}};
		249	sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
		250	static_cast<double>(te.toMSecsSinceEpoch())};
		251
		252	notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
		253	QCOMPARE(notInCach.size(), 0);
244	}	254	}
245		255
246		256

gui/include/Visualization/VisualizationGraphWidget.h +4 0

             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
             class QCPRange;
+            class SqpDateTime;
             class Variable;
             namespace Ui {
                 void updateDisplay(std::shared_ptr<Variable> variable);
+            signals:
+                void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
             private:
                 Ui::VisualizationGraphWidget *ui;

gui/src/Visualization/VisualizationGraphHelper.cpp +15 -13

                 timer.start();
                 if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
                     // Clean the graph
-                    qCDebug(LOG_VisualizationGraphHelper()) << "The slow s1 operation took" << timer.elapsed()
-                                                            << "milliseconds";
                     // NAIVE approch
                     const auto &xData = scalarSeries.xAxisData()->data();
                     const auto &valuesData = scalarSeries.valuesData()->data();
+                    const auto count = xData.count();
+                    qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache" << xData.count();
-                    auto xValue = QVector<double>();
+                    auto xValue = QVector<double>(count);
-                    auto vValue = QVector<double>();
+                    auto vValue = QVector<double>(count);
-                    const auto count = xData.count();
+                    int n = 0;
-                    auto ite = 0;
                     for (auto i = 0; i < count; ++i) {
-                        const auto x = xData.at(i);
+                        const auto x = xData[i];
                         if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) {
-                            xValue.push_back(x);
+                            xValue[n] = x;
-                            vValue.push_back(valuesData.at(i));
+                            vValue[n] = valuesData[i];
-                            ++ite;
+                            ++n;
                         }
                     }
-                    qcpGraph->setData(xValue, vValue);
+                    xValue.resize(n);
+                    vValue.resize(n);
-                    qCDebug(LOG_VisualizationGraphHelper()) << "The slow s2 operation took" << timer.elapsed()
+                    qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed"
-                                                            << "milliseconds";
+                                                           << xValue.count();
+                    qcpGraph->setData(xValue, vValue);
                 }
                 else {
                     /// @todo DEBUG

gui/src/Visualization/VisualizationGraphWidget.cpp +5 -6

                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
+                connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
+                        &VariableController::onRequestDataLoading);
             }
                     impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                 }
-                connect(variable.get(), SIGNAL(dataCacheUpdated()), this, SLOT(onDataCacheVariableUpdated()));
+                connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                     auto variable = it->first;
-                    qCInfo(LOG_VisualizationGraphWidget())
-                        << tr("TORM: VisualizationGraphWidget::onRangeChanged")
-                        << variable->dataSeries()->xAxisData()->size();
                     auto dateTime = SqpDateTime{t2.lower, t2.upper};
                     if (!variable->contains(dateTime)) {
                         variable->setDateTime(dateTime);
                         // CHangement detected, we need to ask controller to request data loading
-                        sqpApp->variableController().requestDataLoading(variable,
+                        emit requestDataLoading(variable, variableDateTimeWithTolerance);
-                                                                        variableDateTimeWithTolerance);
                     }
                 }
             }

plugins/mockplugin/src/CosinusProvider.cpp +9 -6

             #include <cmath>
+            #include <QDateTime>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
             std::unique_ptr<IDataSeries>
                 auto start = dateTime.m_TStart;
                 auto end = dateTime.m_TEnd;
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
             std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTime &dateTime)
             {
+                auto dataIndex = 0;
                 // Gets the timerange from the parameters
-                auto start = dateTime.m_TStart;
+                double freq = 100.0;
-                auto end = dateTime.m_TEnd;
+                double start = dateTime.m_TStart * freq; // 100 htz
+                double end = dateTime.m_TEnd * freq;     // 100 htz
                 // We assure that timerange is valid
                 if (end < start) {
                 auto scalarSeries
                     = std::make_shared<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
-                auto dataIndex = 0;
                 for (auto time = start; time < end; ++time, ++dataIndex) {
-                    scalarSeries->setData(dataIndex, time, std::cos(time));
+                    const auto timeOnFreq = time / freq;
+                    scalarSeries->setData(dataIndex, timeOnFreq, std::cos(timeOnFreq));
                 }
                 return scalarSeries;
             }

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