GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r241:1a61ee1f7b08

Implementation of the new Dela T computation strategy

perrinel -

r241:1a61ee1f7b08

parent child

Context file:

r241:1a61ee1f7b08

app/src/Main.cpp +5 -3

             /*------------------------------------------------------------------------------
             -- This file is a part of the QLop Software
             -- Copyright (C) 2015, 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 <QProcessEnvironment>
             #include <QThread>
             #include <SqpApplication.h>
             #include <qglobal.h>
             #include <Plugin/PluginManager.h>
             #include <QDir>
             namespace {
             /// Name of the directory containing the plugins
             #if _WIN32 || _WIN64
             const auto PLUGIN_DIRECTORY_NAME = QStringLiteral("plugins");
             #endif
             #if __GNUC__
             #if __x86_64__ || __ppc64__
             #define ENVIRONMENT64
             #else
             #define ENVIRONMENT32
             #endif
             #endif
             } // namespace
             int main(int argc, char *argv[])
             {
                 SqpApplication a{argc, argv};
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop");
                 MainWindow w;
                 w.show();
                 // Loads plugins
                 auto pluginDir = QDir{sqpApp->applicationDirPath()};
             #if _WIN32 || _WIN64
                 pluginDir.mkdir(PLUGIN_DIRECTORY_NAME);
                 pluginDir.cd(PLUGIN_DIRECTORY_NAME);
             #endif
             #if __GNUC__
             #if __x86_64__ || __ppc64__
-                pluginDir.cd("../lib64/SciQlop");
+                if (!pluginDir.cd("../lib64/SciQlop")) {
+                    pluginDir.cd("../lib64/sciqlop");
+                }
             #else
-                pluginDir.cd("../lib/SciQlop");
+                __x86_64__ || __ppc64__ if (!pluginDir.cd("../lib/SciQlop")) { pluginDir.cd("../lib/sciqlop"); }
-            #endif
+                #endif
             #endif
                 qCDebug(LOG_PluginManager())
                     << QObject::tr("Plugin directory: %1").arg(pluginDir.absolutePath());
                 PluginManager pluginManager{};
                 pluginManager.loadPlugins(pluginDir);
                 return a.exec();
             }

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

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_Variable)
             class IDataSeries;
             class QString;
             /**
              * @brief The Variable class represents a variable in SciQlop.
              */
             class Variable : public QObject {
                 Q_OBJECT
             public:
                 explicit Variable(const QString &name, const QString &unit, const QString &mission,
                                   const SqpDateTime &dateTime);
                 QString name() const noexcept;
                 QString mission() const noexcept;
                 QString unit() const noexcept;
                 SqpDateTime dateTime() const noexcept;
+                void setDateTime(const SqpDateTime &dateTime) noexcept;
                 /// @return the data of the variable, nullptr if there is no data
                 IDataSeries *dataSeries() const noexcept;
                 bool contains(const SqpDateTime &dateTime);
                 bool intersect(const SqpDateTime &dateTime);
                 void setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
             public slots:
                 void onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             signals:
                 void dataCacheUpdated();
             private:
                 class VariablePrivate;
                 spimpl::unique_impl_ptr<VariablePrivate> impl;
             };
             // Required for using shared_ptr in signals/slots
             Q_DECLARE_METATYPE(std::shared_ptr<Variable>)
             #endif // SCIQLOP_VARIABLE_H

core/src/Variable/Variable.cpp +6 -13

             #include "Variable/Variable.h"
             #include <Data/IDataSeries.h>
             #include <Data/SqpDateTime.h>
             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
             struct Variable::VariablePrivate {
                 explicit VariablePrivate(const QString &name, const QString &unit, const QString &mission,
                                          const SqpDateTime &dateTime)
                         : m_Name{name},
                           m_Unit{unit},
                           m_Mission{mission},
                           m_DateTime{dateTime},
                           m_DataSeries{nullptr}
                 {
                 }
                 QString m_Name;
                 QString m_Unit;
                 QString m_Mission;
                 SqpDateTime m_DateTime; // The dateTime available in the view and loaded. not the cache.
                 std::unique_ptr<IDataSeries> m_DataSeries;
             };
             Variable::Variable(const QString &name, const QString &unit, const QString &mission,
                                const SqpDateTime &dateTime)
                     : impl{spimpl::make_unique_impl<VariablePrivate>(name, unit, mission, dateTime)}
             {
             }
             QString Variable::name() const noexcept
             {
                 return impl->m_Name;
             }
             QString Variable::mission() const noexcept
             {
                 return impl->m_Mission;
             }
             QString Variable::unit() const noexcept
             {
                 return impl->m_Unit;
             }
             SqpDateTime Variable::dateTime() const noexcept
             {
                 return impl->m_DateTime;
             }
+            void Variable::setDateTime(const SqpDateTime &dateTime) noexcept
+            {
+                impl->m_DateTime = dateTime;
+            }
             void Variable::setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (!impl->m_DataSeries) {
                     impl->m_DataSeries = std::move(dataSeries);
                 }
             }
             void Variable::onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (impl->m_DataSeries) {
                     impl->m_DataSeries->merge(dataSeries.get());
                     emit dataCacheUpdated();
                 }
             }
             IDataSeries *Variable::dataSeries() const noexcept
             {
                 return impl->m_DataSeries.get();
             }
             bool Variable::contains(const SqpDateTime &dateTime)
             {
-                if (!impl->m_DateTime.contains(dateTime)) {
+                return impl->m_DateTime.contains(dateTime);
-                    // The current variable dateTime isn't enough to display the dateTime requested.
-                    // We have to update it to the new dateTime requested.
-                    // the correspondant new data to display will be given by the cache if possible and the
-                    // provider if necessary.
-                    qCInfo(LOG_Variable()) << "NEW DATE NEEDED";
-                    //  impl->m_DateTime = dateTime;
-                    return false;
-                return true;
             }
             bool Variable::intersect(const SqpDateTime &dateTime)
             {
                 return impl->m_DateTime.intersect(dateTime);
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +20 -13

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 // 1 variable -> n qcpplot
                 std::unordered_multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *>
                     m_VariableToPlotMultiMap;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 // qcpplot title
                 ui->widget->plotLayout()->insertRow(0);
                 ui->widget->plotLayout()->addElement(0, 0, new QCPTextElement{ui->widget, name});
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
                                                &QCPAxis::rangeChanged),
                         this, &VisualizationGraphWidget::onRangeChanged);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 for (auto createdPlottable : qAsConst(createdPlottables)) {
                     impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                 }
                 connect(variable.get(), SIGNAL(dataCacheUpdated()), this, SLOT(onDataCacheVariableUpdated()));
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visit(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationGraphWidget::canDrop(const Variable &variable) const
             {
                 /// @todo : for the moment, a graph can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             void VisualizationGraphWidget::close()
             {
                 // The main view cannot be directly closed.
                 return;
             }
             QString VisualizationGraphWidget::name() const
             {
                 if (auto title = dynamic_cast<QCPTextElement *>(ui->widget->plotLayout()->elementAt(0))) {
                     return title->text();
                 }
                 else {
                     return QString{};
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged");
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      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)) {
+                        auto variableDateTimeWithTolerance = dateTime;
                         if (variable->intersect(dateTime)) {
                             auto variableDateTime = variable->dateTime();
                             if (variableDateTime.m_TStart < dateTime.m_TStart) {
                                 dateTime.m_TStart = variableDateTime.m_TStart;
-                                // add 20% tolerance for left (start) side
+                                // START is set to the old one. tolerance have to be added to the right
-                                auto tolerance = 0.2 * (dateTime.m_TEnd - dateTime.m_TStart);
+                                // add 10% tolerance for right (end) side
-                                dateTime.m_TStart -= tolerance;
+                                auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
+                                variableDateTimeWithTolerance.m_TEnd += tolerance;
                             }
                             if (variableDateTime.m_TEnd > dateTime.m_TEnd) {
                                 dateTime.m_TEnd = variableDateTime.m_TEnd;
-                                // add 20% tolerance for right (end) side
+                                // END is set to the old one. tolerance have to be added to the left
-                                auto tolerance = 0.2 * (dateTime.m_TEnd - dateTime.m_TStart);
+                                // add 10% tolerance for left (start) side
-                                dateTime.m_TEnd += tolerance;
+                                auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
+                                variableDateTimeWithTolerance.m_TStart -= tolerance;
                             }
                         }
                         else {
                             // add 10% tolerance for each side
                             auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
-                            dateTime.m_TStart -= tolerance;
+                            variableDateTimeWithTolerance.m_TStart -= tolerance;
-                            dateTime.m_TEnd += tolerance;
+                            variableDateTimeWithTolerance.m_TEnd += tolerance;
                         }
-                        // CHangement detected, we need to
+                        variable->setDateTime(dateTime);
-                        sqpApp->variableController().requestDataLoading(variable, dateTime);
+                        // CHangement detected, we need to ask controller to request data loading
+                        sqpApp->variableController().requestDataLoading(variable,
+                                                                        variableDateTimeWithTolerance);
                     }
                 }
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
-                // Lambda that enables a zoom orientation if the key modifier related to this orientation has
+                // Lambda that enables a zoom orientation if the key modifier related to this orientation
+                // has
                 // been pressed
                 auto enableOrientation
                     = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                           auto orientationEnabled = event->modifiers().testFlag(modifier);
                           zoomOrientations.setFlag(orientation, orientationEnabled);
                       };
                 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 // NOTE:
-                //    We don't want to call the method for each component of a variable unitarily, but for all
+                //    We don't want to call the method for each component of a variable unitarily, but for
+                //    all
                 //    its components at once (eg its three components in the case of a vector).
                 //    The unordered_multimap does not do this easily, so the question is whether to:
                 //    - use an ordered_multimap and the algos of std to group the values by key
                 //    - use a map (unique keys) and store as values directly the list of components
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                     auto variable = it->first;
                     VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
                                                          variable->dataSeries(), variable->dateTime());
                 }
             }
             void VisualizationGraphWidget::updateDisplay(std::shared_ptr<Variable> variable)
             {
                 auto abstractPlotableItPair = impl->m_VariableToPlotMultiMap.equal_range(variable);
                 auto abstractPlotableVect = QVector<QCPAbstractPlottable *>{};
                 for (auto it = abstractPlotableItPair.first; it != abstractPlotableItPair.second; ++it) {
                     abstractPlotableVect.push_back(it->second);
                 }
                 VisualizationGraphHelper::updateData(abstractPlotableVect, variable->dataSeries(),
                                                      variable->dateTime());
             }

General Comments 3

perrinel

|

Auto status change to "Under Review"

perrinel

|

Status change > Approved

Write
Preview

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

	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