GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r511:bf486b19bffa

Add synchronization part of v5 acquisition

perrinel -

r511:bf486b19bffa

parent child

Context file:

r511: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;
-                     qCCritical(LOG_VariableController()) << tr("2: onDataProvided") << cacheRangeRequested;
+                     qCDebug(LOG_VariableController()) << tr("1: onDataProvided") << rangeRequested;
+                     qCDebug(LOG_VariableController()) << tr("2: onDataProvided") << cacheRangeRequested;
                      auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
-                     qCCritical(LOG_VariableController()) << tr("3: onDataProvided")
-                                                          << retrievedDataSeries->range();
+                     qCDebug(LOG_VariableController()) << tr("3: onDataProvided")
+                                                       << 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);
            


        

    

      

  

      
          

              

                    
                        
                        note
                    

              
          
          
              
  

  
    
  
  

  

    
        perrinel
    
  

          

          
              Wed, 16 Aug 2017 14:50:36
          


          

              
                
              

          

                    
                    

            
              
              

                
                    Comment #1891
                    
                

                      
                      
                        Edit
                      
                      
                        Delete
                      
              
            

            |
                 
                 

          
      
      
          ok
+                 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);
-                         if (vToVIdit != impl->m_VariableToIdentifierMap.cend()) {
-                             auto vId = vToVIdit->second;
-                             auto vIdToGIdit = impl->m_VariableIdGroupIdMap.find(vId);
-                             if (vIdToGIdit != impl->m_VariableIdGroupIdMap.cend()) {
-                                 auto gId = vToVIdit->second;
+                         auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(var);
+                         if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
+                             auto vId = varToVarIdIt->second;
+                             auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
+                             if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
+                                 auto gId = varIdToGroupIdIt->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();
-                                 auto vSyncRangeRequested
-                                     = computeSynchroRangeRequested(var->range(), range, oldRange);
-                                 impl->processRequest(var, vSyncRangeRequested);
+                             }
-                             else {
-                                 qCCritical(LOG_VariableController())
-                                     << tr("Impossible to synchronize a null variable");
+                             // Don't process already processed var
+                             if (!variables.contains(var)) {
+                                 if (var != nullptr) {
+                                     qCDebug(LOG_VariableController()) << "processRequest synchro for"
+                                                                       << var->name();
+                                     auto vSyncRangeRequested
+                                         = computeSynchroRangeRequested(var->range(), range, oldRange);
+                                     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")
-                     << QVector<double>{1., 2., 3., 4., 5.} << -1 << QVector<double>{};
+                 QTest::newRow("invalidIndex1") << QVector<double>{1., 2., 3., 4., 5.} << -1
+                                                << 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")
-                     << DataContainer{{1., 2., 3., 4., 5.}} << false << DataContainer{{}, {}, {}};
+                 QTest::newRow("invalidInput (less than tow components") << DataContainer{{1., 2., 3., 4., 5.}}
+                                                                         << 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
-                 //    // when adding a variable, we need to set its time range to the current graph range
-                 //    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});
-                 //    }
+                 // Uses delegate to create the qcpplot components according to the variable
+                 this->addVariable(variable);
-                 //    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(variable, variableDateTimeWithTolerance);
+                 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable,
+                                         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);
            


        

    

      

  

      
          

              

                    
                        
                        note
                    

              
          
          
              
  

  
    
  
  

  

    
        perrinel
    
  

          

          
              Wed, 16 Aug 2017 14:52:09
          


          

              
                
              

          

                    
                    

            
              
              

                
                    Comment #1892
                    
                

                      
                      
                        Edit
                      
                      
                        Delete
                      
              
            

            |
                 
                 

          
      
      
          ok
                  }
              }

General Comments 1

perrinel

|

Auto status change to "Under Review"

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