GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r781:958cef2901c0

Changes plugin products to integrate parametric frequencies

Alexandre Leroux -

r781:958cef2901c0

parent child

Context file:

r781:958cef2901c0

Collapse all files

plugins/mockplugin/src/MockPlugin.cpp +12 -2

             #include "MockPlugin.h"
             #include "CosinusProvider.h"
             #include "MockDefs.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_MockPlugin, "MockPlugin")
             namespace {
             /// Name of the data source
             const auto DATA_SOURCE_NAME = QStringLiteral("MMS");
             /// Creates the data provider relative to the plugin
             std::unique_ptr<IDataProvider> createDataProvider() noexcept
             {
                 return std::make_unique<CosinusProvider>();
             }
             std::unique_ptr<DataSourceItem> createProductItem(const QVariantHash &data,
                                                               const QUuid &dataSourceUid)
             {
                 auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, data);
                 auto productName = data.value(DataSourceItem::NAME_DATA_KEY).toString();
                 // Add action to load product from DataSourceController
                 result->addAction(std::make_unique<DataSourceItemAction>(
                     QObject::tr("Load %1 product").arg(productName),
                     [productName, dataSourceUid](DataSourceItem &item) {
                         if (auto app = sqpApp) {
                             app->dataSourceController().loadProductItem(dataSourceUid, item);
                         }
                     }));
                 return result;
             }
             /// Creates the data source item relative to the plugin
             std::unique_ptr<DataSourceItem> createDataSourceItem(const QUuid &dataSourceUid) noexcept
             {
                 // Magnetic field products
                 auto magneticFieldFolder = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
                                                                             QStringLiteral("Magnetic field"));
-                magneticFieldFolder->appendChild(createProductItem(QStringLiteral("FGM"), dataSourceUid));
+                magneticFieldFolder->appendChild(
-                magneticFieldFolder->appendChild(createProductItem(QStringLiteral("SC"), dataSourceUid));
+                    createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Scalar 10 Hz")},
+                                       {COSINUS_FREQUENCY_KEY, 10.}},
+                                      dataSourceUid));
+                magneticFieldFolder->appendChild(
+                    createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Scalar 60 Hz")},
+                                       {COSINUS_FREQUENCY_KEY, 60.}},
+                                      dataSourceUid));
+                magneticFieldFolder->appendChild(
+                    createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Scalar 100 Hz")},
+                                       {COSINUS_FREQUENCY_KEY, 100.}},
+                                      dataSourceUid));
                 // Electric field products
                 auto electricFieldFolder = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
                                                                             QStringLiteral("Electric field"));
                 // Root
                 auto root = std::make_unique<DataSourceItem>(DataSourceItemType::NODE, DATA_SOURCE_NAME);
                 root->appendChild(std::move(magneticFieldFolder));
                 root->appendChild(std::move(electricFieldFolder));
                 return root;
             }
             } // namespace
             void MockPlugin::initialize()
             {
                 if (auto app = sqpApp) {
                     // Registers to the data source controller
                     auto &dataSourceController = app->dataSourceController();
                     auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
                     // Sets data source tree
                     dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem(dataSourceUid));
                     // Sets data provider
                     dataSourceController.setDataProvider(dataSourceUid, createDataProvider());
                 }
                 else {
                     qCWarning(LOG_MockPlugin()) << tr("Can't access to SciQlop application");
                 }
             }

plugins/mockplugin/tests/TestCosinusAcquisition.cpp +3 -1

             #include "CosinusProvider.h"
+            #include "MockDefs.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QObject>
             #include <QtTest>
             #include <cmath>
             #include <memory>
             namespace {
             /// Path for the tests
             const auto TESTS_RESOURCES_PATH = QFileInfo{
                 QString{MOCKPLUGIN_TESTS_RESOURCES_DIR},
                 "TestCosinusAcquisition"}.absoluteFilePath();
             /// Format of dates in data files
             const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");
             /// Delay after each operation on the variable before validating it (in ms)
             const auto OPERATION_DELAY = 250;
             /**
              * Verifies that the data in the candidate series are identical to the data in the reference series
              * in a specific range
              * @param candidate the candidate data series
              * @param range the range to check
              * @param reference the reference data series
              * @return true if the data of the candidate series and the reference series are identical in the
              * range, false otherwise
              */
             bool checkDataSeries(std::shared_ptr<IDataSeries> candidate, const SqpRange &range,
                                  std::shared_ptr<IDataSeries> reference)
             {
                 if (candidate == nullptr || reference == nullptr) {
                     return candidate == reference;
                 }
                 auto referenceIt = reference->xAxisRange(range.m_TStart, range.m_TEnd);
                 return std::equal(candidate->cbegin(), candidate->cend(), referenceIt.first, referenceIt.second,
                                   [](const auto &it1, const auto &it2) {
                                       // - milliseconds precision for time
                                       // - 1e-6 precision for value
                                       return std::abs(it1.x() - it2.x()) < 1e-3
                                              && std::abs(it1.value() - it2.value()) < 1e-6;
                                   });
             }
             /// Generates the data series from the reading of a data stream
             std::shared_ptr<IDataSeries> readDataStream(QTextStream &stream)
             {
                 std::vector<double> xAxisData, valuesData;
                 QString line{};
                 while (stream.readLineInto(&line)) {
                     // Separates date (x-axis data) to value data
                     auto splitLine = line.split('\t');
                     if (splitLine.size() == 2) {
                         // Converts datetime to double
                         auto dateTime = QDateTime::fromString(splitLine[0], DATETIME_FORMAT);
                         dateTime.setTimeSpec(Qt::UTC);
                         xAxisData.push_back(DateUtils::secondsSinceEpoch(dateTime));
                         valuesData.push_back(splitLine[1].toDouble());
                     }
                 }
                 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                       Unit{{}, true}, Unit{});
             }
             } // namespace
             /**
              * @brief The TestCosinusAcquisition class tests acquisition in SciQlop (operations like zooms in,
              * zooms out, pans) of data from CosinusProvider
              * @sa CosinusProvider
              */
             class TestCosinusAcquisition : public QObject {
                 Q_OBJECT
             private slots:
                 /// Input data for @sa testAcquisition()
                 void testAcquisition_data();
                 void testAcquisition();
             };
             void TestCosinusAcquisition::testAcquisition_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 QTest::addColumn<QString>("dataFilename");  // File containing expected data of acquisitions
                 QTest::addColumn<SqpRange>("initialRange"); // First acquisition
                 QTest::addColumn<std::vector<SqpRange> >("operations"); // Acquisitions to make
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 auto dateTime = [](int year, int month, int day, int hours, int minutes, int seconds) {
                     return DateUtils::secondsSinceEpoch(
                         QDateTime{{year, month, day}, {hours, minutes, seconds}, Qt::UTC});
                 };
                 QTest::newRow("cosinus")
                     << "Cosinus_100Hz_20170101_1200_20170101_1300.txt"
                     << SqpRange{dateTime(2017, 1, 1, 12, 30, 0), dateTime(2017, 1, 1, 12, 35, 1)}
                     << std::vector<SqpRange>{
                            // Pan (jump) left
                            SqpRange{dateTime(2017, 1, 1, 12, 45, 0), dateTime(2017, 1, 1, 12, 50, 0)},
                            // Pan (jump) right
                            SqpRange{dateTime(2017, 1, 1, 12, 15, 0), dateTime(2017, 1, 1, 12, 20, 0)},
                            // Pan (overlay) right
                            SqpRange{dateTime(2017, 1, 1, 12, 14, 0), dateTime(2017, 1, 1, 12, 19, 0)},
                            // Pan (overlay) left
                            SqpRange{dateTime(2017, 1, 1, 12, 15, 0), dateTime(2017, 1, 1, 12, 20, 0)},
                            // Pan (overlay) left
                            SqpRange{dateTime(2017, 1, 1, 12, 16, 0), dateTime(2017, 1, 1, 12, 21, 0)},
                            // Zoom in
                            SqpRange{dateTime(2017, 1, 1, 12, 17, 30), dateTime(2017, 1, 1, 12, 19, 30)},
                            // Zoom out
                            SqpRange{dateTime(2017, 1, 1, 12, 12, 30), dateTime(2017, 1, 1, 12, 24, 30)}};
             }
             void TestCosinusAcquisition::testAcquisition()
             {
                 // Retrieves data file
                 QFETCH(QString, dataFilename);
                 auto dataFilePath = QFileInfo{TESTS_RESOURCES_PATH, dataFilename}.absoluteFilePath();
                 QFile dataFile{dataFilePath};
                 if (dataFile.open(QFile::ReadOnly)) {
                     // Generates data series to compare with
                     QTextStream dataStream{&dataFile};
                     auto dataSeries = readDataStream(dataStream);
                     /// Lambda used to validate a variable at each step
                     auto validateVariable = [dataSeries](std::shared_ptr<Variable> variable,
                                                          const SqpRange &range) {
                         // Checks that the variable's range has changed
                         QCOMPARE(variable->range(), range);
                         // Checks the variable's data series
                         QVERIFY(checkDataSeries(variable->dataSeries(), variable->cacheRange(), dataSeries));
                     };
                     // Creates variable
                     QFETCH(SqpRange, initialRange);
                     sqpApp->timeController().onTimeToUpdate(initialRange);
                     auto provider = std::make_shared<CosinusProvider>();
-                    auto variable = sqpApp->variableController().createVariable("MMS", {}, provider);
+                    auto variable = sqpApp->variableController().createVariable(
+                        "MMS", {{COSINUS_TYPE_KEY, "scalar"}, {COSINUS_FREQUENCY_KEY, 100.}}, provider);
                     QTest::qWait(OPERATION_DELAY);
                     validateVariable(variable, initialRange);
                     // Makes operations on the variable
                     QFETCH(std::vector<SqpRange>, operations);
                     for (const auto &operation : operations) {
                         // Asks request on the variable and waits during its execution
                         sqpApp->variableController().onRequestDataLoading({variable}, operation,
                                                                           variable->range(), true);
                         QTest::qWait(OPERATION_DELAY);
                         validateVariable(variable, operation);
                     }
                 }
                 else {
                     QFAIL("Can't read input data file");
                 }
             }
             int main(int argc, char *argv[])
             {
                 SqpApplication app{argc, argv};
                 app.setAttribute(Qt::AA_Use96Dpi, true);
                 TestCosinusAcquisition testObject{};
                 QTEST_SET_MAIN_SOURCE_PATH
                 return QTest::qExec(&testObject, argc, argv);
             }
             #include "TestCosinusAcquisition.moc"

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