GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r540:bf486b19bffa

Add synchronization part of v5 acquisition

perrinel -

r540:bf486b19bffa

parent child

Context file:

r540:bf486b19bffa

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

                 /// synchronization group methods
                 void onAddSynchronizationGroupId(QUuid synchronizationGroupId);
                 void onRemoveSynchronizationGroupId(QUuid synchronizationGroupId);
+                void onAddSynchronized(std::shared_ptr<Variable> variable, QUuid synchronizationGroupId);
                 void initialize();
                 void finalize();

core/src/Variable/VariableController.cpp +60 -25

                                                     const SqpRange &cacheRangeRequested,
                                                     QVector<AcquisitionDataPacket> dataAcquired)
             {
-                qCCritical(LOG_VariableController()) << tr("onDataProvided") << dataAcquired.isEmpty();
                 auto var = impl->findVariable(vIdentifier);
                 if (var != nullptr) {
                     var->setRange(rangeRequested);
                     var->setCacheRange(cacheRangeRequested);
-                    qCCritical(LOG_VariableController()) << tr("1: onDataProvided") << rangeRequested;
+                    qCDebug(LOG_VariableController()) << tr("1: onDataProvided") << rangeRequested;
-                    qCCritical(LOG_VariableController()) << tr("2: onDataProvided") << cacheRangeRequested;
+                    qCDebug(LOG_VariableController()) << tr("2: onDataProvided") << cacheRangeRequested;
                     auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
-                    qCCritical(LOG_VariableController()) << tr("3: onDataProvided")
+                    qCDebug(LOG_VariableController()) << tr("3: onDataProvided")
-                                                         << retrievedDataSeries->range();
+                                                      << retrievedDataSeries->range();
                     var->mergeDataSeries(retrievedDataSeries);
                     emit var->updated();
                 }
             void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
             {
+                qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
+                                                  << QThread::currentThread()->objectName()
+                                                  << synchronizationGroupId;
                 auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
                 impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
                     std::make_pair(synchronizationGroupId, vSynchroGroup));
                 impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);
             }
+            void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
+                                                       QUuid synchronizationGroupId)
+            {
+                qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
+                                                  << synchronizationGroupId;
+                auto vToVIdit = impl->m_VariableToIdentifierMap.find(variable);
+                if (vToVIdit != impl->m_VariableToIdentifierMap.cend()) {
+                    auto itSynchroGroup
+                        = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
+                    if (itSynchroGroup != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
+                        impl->m_VariableIdGroupIdMap.insert(
+                            std::make_pair(vToVIdit->second, synchronizationGroupId));
+                        itSynchroGroup->second->addVariableId(vToVIdit->second);
+                    }
+                    else {
+                        qCCritical(LOG_VariableController())
+                            << tr("Impossible to synchronize a variable with an unknown sycnhronization group")
+                            << variable->name();
+                    }
+                }
+                else {
+                    qCCritical(LOG_VariableController())
+                        << tr("Impossible to synchronize a variable with no identifier") << variable->name();
+                }
+            }
             void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
                                                           const SqpRange &range, const SqpRange &oldRange,
                 // For the other, we ask the provider to give them.
                 foreach (auto var, variables) {
-                    qCInfo(LOG_VariableController()) << "processRequest for" << var->name();
+                    qCDebug(LOG_VariableController()) << "processRequest for" << var->name();
                     impl->processRequest(var, range);
                 }
                 if (synchronise) {
                     // Get the group ids
-                    qCInfo(LOG_VariableController())
+                    qCDebug(LOG_VariableController())
                         << "VariableController::onRequestDataLoading for synchro var ENABLE";
                     auto groupIds = std::set<QUuid>();
                     foreach (auto var, variables) {
-                        auto vToVIdit = impl->m_VariableToIdentifierMap.find(var);
+                        auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(var);
-                        if (vToVIdit != impl->m_VariableToIdentifierMap.cend()) {
+                        if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
-                            auto vId = vToVIdit->second;
+                            auto vId = varToVarIdIt->second;
+                            auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
-                            auto vIdToGIdit = impl->m_VariableIdGroupIdMap.find(vId);
+                            if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
-                            if (vIdToGIdit != impl->m_VariableIdGroupIdMap.cend()) {
+                                auto gId = varIdToGroupIdIt->second;
-                                auto gId = vToVIdit->second;
                                 if (groupIds.find(gId) == groupIds.cend()) {
+                                    qCDebug(LOG_VariableController()) << "Synchro detect group " << gId;
                                     groupIds.insert(gId);
                                 }
                             }
                     foreach (auto gId, groupIds) {
                         auto vSynchronizationGroup = impl->m_GroupIdToVariableSynchronizationGroupMap.at(gId);
                         auto vSyncIds = vSynchronizationGroup->getIds();
+                        qCDebug(LOG_VariableController()) << "Var in synchro group ";
                         for (auto vId : vSyncIds) {
                             auto var = impl->findVariable(vId);
-                            if (var != nullptr) {
-                                qCInfo(LOG_VariableController()) << "processRequest synchro for" << var->name();
+                            // Don't process already processed var
-                                auto vSyncRangeRequested
+                            if (!variables.contains(var)) {
-                                    = computeSynchroRangeRequested(var->range(), range, oldRange);
+                                if (var != nullptr) {
-                                impl->processRequest(var, vSyncRangeRequested);
+                                    qCDebug(LOG_VariableController()) << "processRequest synchro for"
+                                                                      << var->name();
-                            else {
+                                    auto vSyncRangeRequested
-                                qCCritical(LOG_VariableController())
+                                        = computeSynchroRangeRequested(var->range(), range, oldRange);
-                                    << tr("Impossible to synchronize a null variable");
+                                    impl->processRequest(var, vSyncRangeRequested);
+                                }
+                                else {
+                                    qCCritical(LOG_VariableController())
+                                        << tr("Impossible to synchronize a null variable");
+                                }
                             }
                         }
                     }
                             &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
                 }
                 else {
-                    qCInfo(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
+                    qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
                 }
             }

core/tests/Data/TestOneDimArrayData.cpp +2 -2

                 // Test cases
                 QTest::newRow("validIndex") << QVector<double>{1., 2., 3., 4., 5.} << 0
                                             << QVector<double>{1., 2., 3., 4., 5.};
-                QTest::newRow("invalidIndex1")
+                QTest::newRow("invalidIndex1") << QVector<double>{1., 2., 3., 4., 5.} << -1
-                    << QVector<double>{1., 2., 3., 4., 5.} << -1 << QVector<double>{};
+                                               << QVector<double>{};
                 QTest::newRow("invalidIndex2") << QVector<double>{1., 2., 3., 4., 5.} << 1 << QVector<double>{};
             }

core/tests/Data/TestTwoDimArrayData.cpp +2 -2

                 QTest::newRow("malformedInput (components of the array data haven't the same size")
                     << DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8.}, {11., 12.}} << true
                     << DataContainer{{}, {}, {}};
-                QTest::newRow("invalidInput (less than tow components")
+                QTest::newRow("invalidInput (less than tow components") << DataContainer{{1., 2., 3., 4., 5.}}
-                    << DataContainer{{1., 2., 3., 4., 5.}} << false << DataContainer{{}, {}, {}};
+                                                                        << false << DataContainer{{}, {}, {}};
             }
             void TestTwoDimArrayData::testCtor()

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

                                         const SqpRange &oldRange, bool synchronise);
+                void variableAdded(std::shared_ptr<Variable> var);
             private:
                 Ui::VisualizationGraphWidget *ui;

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

                 bool contains(const Variable &variable) const override;
                 QString name() const override;
+            private slots:
+                void onVariableAdded(std::shared_ptr<Variable> variable);
             private:
                 Ui::VisualizationZoneWidget *ui;

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

             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
             {
+                auto calibrationState = impl->m_IsCalibration;
+                impl->m_IsCalibration = true;
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
+                impl->m_IsCalibration = calibrationState;
                 for (auto createdPlottable : qAsConst(createdPlottables)) {
                     impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                 }
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
+                emit variableAdded(variable);
             }
             void VisualizationGraphWidget::addVariableUsingGraph(std::shared_ptr<Variable> variable)
             {
-                // TODO
+                // Uses delegate to create the qcpplot components according to the variable
-                //    // when adding a variable, we need to set its time range to the current graph range
+                this->addVariable(variable);
-                //    auto grapheRange = ui->widget->xAxis->range();
-                //    auto dateTime = SqpRange{grapheRange.lower, grapheRange.upper};
-                //    variable->setDateTime(dateTime);
-                //    auto variableDateTimeWithTolerance = dateTime;
-                //    // add tolerance for each side
-                //    auto toleranceFactor
-                //        = toleranceValue(GENERAL_TOLERANCE_AT_INIT_KEY,
-                //        GENERAL_TOLERANCE_AT_INIT_DEFAULT_VALUE);
-                //    auto tolerance = toleranceFactor * (dateTime.m_TEnd - dateTime.m_TStart);
-                //    variableDateTimeWithTolerance.m_TStart -= tolerance;
-                //    variableDateTimeWithTolerance.m_TEnd += tolerance;
-                //    // 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(updated()), this, SLOT(onDataCacheVariableUpdated()));
+                // Request range for the variable
+                auto graphRange = ui->widget->xAxis->range();
-                //    // CHangement detected, we need to ask controller to request data loading
+                emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable,
-                //    emit requestDataLoading(variable, variableDateTimeWithTolerance);
+                                        SqpRange{graphRange.lower, graphRange.upper}, variable->range(), false);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
                                             !impl->m_IsCalibration);
                     if (!impl->m_IsCalibration) {
-                        qCDebug(LOG_VisualizationGraphWidget())
+                        qCInfo(LOG_VisualizationGraphWidget())
                             << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
-                            << QThread::currentThread()->objectName();
+                            << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
                         emit synchronize(graphRange, oldGraphRange);
                     }
                 }

gui/src/Visualization/VisualizationZoneWidget.cpp +13 -3

                 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
                 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
-                this->addGraph(graphWidget);
-                graphWidget->addVariable(variable);
                 // Lambda to synchronize zone widget
                 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &grapheRange,
                 // connection for synchronization
                 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
+                connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
+                        &VisualizationZoneWidget::onVariableAdded);
+                this->addGraph(graphWidget);
+                graphWidget->addVariable(variable);
                 return graphWidget;
             }
             {
                 return ui->zoneNameLabel->text();
             }
+            void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
+            {
+                QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
+                                          Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
+                                          Q_ARG(QUuid, impl->m_SynchronisationGroupId));
+            }

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

                 const auto times = parameters.m_Times;
                 const auto data = parameters.m_Data;
                 for (const auto &dateTime : qAsConst(times)) {
-                    retrieveData(acqIdentifier, dateTime, data);
+                    this->retrieveData(acqIdentifier, dateTime, data);
+                    QThread::msleep(200);
                 }
             }

General Comments 0

Write
Preview

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

No TODOs yet

		ok
		ok

	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