HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Pull Request !290

Closed

Pull request !290 Created on by

perrinel

- Merge branch 'feature/ProgressAndCancel' into develop
- Fix progression bug when aborting a request for Amda plugin
- See last commit
- Fix bug when creating two variables crash the app.
- Update networkcontroller for abort mechanism

Commit flow:

branch:develop of GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation → branch:develop of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Versions:

Pull request versions not available.

Expand 12 commits

ver	Time	Author	Commit	Description
`latest`	Thu, 21 Sep 2017 16:04:25	perrinel	`r704:ff170594501a`	Implementation of automatic cancel for request that failed
`latest`	Thu, 21 Sep 2017 14:01:10	perrinel	`r703:ba0e6f7d7791`	Correction for MR
`v1`	Thu, 21 Sep 2017 09:01:47	perrinel	`r702:7c5b3263c65b`	Merge branch 'feature/ProgressAndCancel' into develop
`v1`	Thu, 21 Sep 2017 08:57:57	perrinel	`r701:87c4dffdd5b8`	Fix progression bug when aborting a request for Amda plugin
`v1`	Thu, 21 Sep 2017 08:57:57	perrinel	`r700:bef126514bff`	See last commit
`v1`	Thu, 21 Sep 2017 08:57:57	perrinel	`r699:a7f60f6512e6`	Fix bug when creating two variables crash the app. Variable as now invalid range and cache range at creation
`v1`	Thu, 21 Sep 2017 08:57:56	perrinel	`r698:076c09acb9f6`	Update networkcontroller for abort mechanism
`v1`	Thu, 21 Sep 2017 08:57:56	perrinel	`r697:2015ea331dc4`	Implementation of abort mechanism
`v1`	Thu, 21 Sep 2017 08:57:56	perrinel	`r696:450aab29f079`	update clang format for qcustomplot
`v1`	Thu, 21 Sep 2017 08:57:56	perrinel	`r695:22c6ca1df132`	Implement progression for AmdaProvider.
`v1`	Thu, 21 Sep 2017 08:57:56	perrinel	`r694:34234d13df5c`	request is now passed by shared pointer instead of const &
`v1`	Thu, 21 Sep 2017 08:57:56	perrinel	`r693:f189aafd213c`	Implementation of progression
12 commits hidden, click expand to show them.

Expand all files

core/src/Variable/VariableCacheStrategy.cpp created 644 +52 0

@@ -0,0 +1,52
	1	#include "Variable/VariableCacheStrategy.h"
	2
	3	#include "Settings/SqpSettingsDefs.h"
	4
	5	#include "Variable/Variable.h"
	6	#include "Variable/VariableController.h"
	7
	8	Q_LOGGING_CATEGORY(LOG_VariableCacheStrategy, "VariableCacheStrategy")
	9
	10	struct VariableCacheStrategy::VariableCacheStrategyPrivate {
	11	VariableCacheStrategyPrivate() : m_CacheStrategy{CacheStrategy::FixedTolerance} {}
	12
	13	CacheStrategy m_CacheStrategy;
	14	};
	15
	16
	17	VariableCacheStrategy::VariableCacheStrategy(QObject *parent)
	18	: QObject{parent}, impl{spimpl::make_unique_impl<VariableCacheStrategyPrivate>()}
	19	{
	20	}
	21
	22	std::pair<SqpRange, SqpRange>
	23	VariableCacheStrategy::computeStrategyRanges(const SqpRange &vRange, const SqpRange &rangeRequested)
	24	{
	25
	26	auto varRanges = std::pair<SqpRange, SqpRange>{};
	27
	28	auto toleranceFactor = SqpSettings::toleranceValue(GENERAL_TOLERANCE_AT_UPDATE_KEY,
	29	GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE);
	30	auto tolerance = toleranceFactor * (rangeRequested.m_TEnd - rangeRequested.m_TStart);
	31
	32	switch (impl->m_CacheStrategy) {
	33	case CacheStrategy::FixedTolerance: {
	34	varRanges.first = rangeRequested;
	35	varRanges.second
	36	= SqpRange{rangeRequested.m_TStart - tolerance, rangeRequested.m_TEnd + tolerance};
	37	break;
	38	}
	39
	40	case CacheStrategy::TwoThreashold: {
	41	// TODO Implement
	42	break;
	43	}
	44	default:
	45	qCCritical(LOG_VariableCacheStrategy())
	46	<< tr("Impossible to use compute the cache range with an unknow cache strategy");
	47	// No action
	48	break;
	49	}
	50
	51	return varRanges;
	52	}

build_cfg/mac/install_script.sh 0 -1

             #!/bin/bash
             mkdir -p ${MESON_INSTALL_PREFIX}/Contents/Frameworks
             mv ${MESON_INSTALL_PREFIX}/lib/*plugin* ${MESON_INSTALL_PREFIX}/Contents/MacOS
             macdeployqt ${MESON_INSTALL_PREFIX} -verbose=3
             install_name_tool -change @rpath/QtCore.framework/Versions/5/QtCore @executable_path/../Frameworks/QtCore.framework/Versions/5/QtCore /tmp/SciQLOP.app/Contents/MacOS/sciqlop
             install_name_tool -change @rpath/QtPrintSupport.framework/Versions/5/QtPrintSupport @executable_path/../Frameworks/QtPrintSupport.framework/Versions/5/QtPrintSupport /tmp/SciQLOP.app/Contents/MacOS/sciqlop
             install_name_tool -change @rpath/QtGui.framework/Versions/5/QtGui @executable_path/../Frameworks/QtGui.framework/Versions/5/QtGui /tmp/SciQLOP.app/Contents/MacOS/sciqlop
             install_name_tool -change @rpath/QtWidgets.framework/Versions/5/QtWidgets @executable_path/../Frameworks/QtWidgets.framework/Versions/5/QtWidgets /tmp/SciQLOP.app/Contents/MacOS/sciqlop
             install_name_tool -change @rpath/QtNetwork.framework/Versions/5/QtNetwork @executable_path/../Frameworks/QtNetwork.framework/Versions/5/QtNetwork /tmp/SciQLOP.app/Contents/MacOS/sciqlop
-            install_name_tool -change @rpath/QtSvg.framework/Versions/5/QtSvg @executable_path/../Frameworks/QtSvg.framework/Versions/5/QtSvg /tmp/SciQLOP.app/Contents/MacOS/sciqlop

core/include/Data/SqpIterator.h +1 -5

             #ifndef SCIQLOP_SQPITERATOR_H
             #define SCIQLOP_SQPITERATOR_H
             #include "CoreGlobal.h"
             /**
              * @brief The SqpIterator class represents an iterator used in SciQlop. It defines all operators
              * needed for a standard forward iterator
              * @tparam T the type of object handled in iterator
              * @sa http://www.cplusplus.com/reference/iterator/
              */
             template <typename T>
             class SCIQLOP_CORE_EXPORT SqpIterator {
             public:
                 using iterator_category = std::random_access_iterator_tag;
                 using value_type = const T;
                 using difference_type = std::ptrdiff_t;
                 using pointer = value_type *;
                 using reference = value_type &;
                 explicit SqpIterator(T value) : m_CurrentValue{std::move(value)} {}
                 virtual ~SqpIterator() noexcept = default;
                 SqpIterator(const SqpIterator &) = default;
-                SqpIterator &operator=(SqpIterator other)
+                SqpIterator &operator=(SqpIterator other) { swap(m_CurrentValue, other.m_CurrentValue); }
-                    swap(m_CurrentValue, other.m_CurrentValue);
-                    return *this;
                 SqpIterator &operator++()
                 {
                     m_CurrentValue.next();
                     return *this;
                 }
                 SqpIterator &operator--()
                 {
                     m_CurrentValue.prev();
                     return *this;
                 }
                 SqpIterator operator++(int)const
                 {
                     auto result = *this;
                     this->operator++();
                     return result;
                 }
                 SqpIterator operator--(int)const
                 {
                     auto result = *this;
                     this->operator--();
                     return result;
                 }
                 SqpIterator &operator+=(int offset)
                 {
                     if (offset >= 0) {
                         m_CurrentValue.next(offset);
                     }
                     else {
                         while (offset++) {
                             m_CurrentValue.prev();
                         }
                     }
                     return *this;
                 }
                 SqpIterator &operator-=(int offset) { return *this += -offset; }
                 SqpIterator operator+(int offset) const
                 {
                     auto result = *this;
                     result += offset;
                     return result;
                 }
                 SqpIterator operator-(int offset) const
                 {
                     auto result = *this;
                     result -= offset;
                     return result;
                 }
                 int operator-(const SqpIterator &other) const
                 {
                     return m_CurrentValue.distance(other.m_CurrentValue);
                 }
                 const T *operator->() const { return &m_CurrentValue; }
                 const T &operator*() const { return m_CurrentValue; }
                 T *operator->() { return &m_CurrentValue; }
                 T &operator*() { return m_CurrentValue; }
                 T &operator[](int offset) const { return m_CurrentValue.advance(offset); }
                 bool operator==(const SqpIterator &other) const
                 {
                     return m_CurrentValue.equals(other.m_CurrentValue);
                 }
                 bool operator!=(const SqpIterator &other) const { return !(*this == other); }
                 bool operator>(const SqpIterator &other) const { return other.m_CurrentValue.lowerThan(*this); }
                 bool operator<(const SqpIterator &other) const
                 {
                     return m_CurrentValue.lowerThan(other.m_CurrentValue);
                 }
                 bool operator>=(const SqpIterator &other) const { return !(*this < other); }
                 bool operator<=(const SqpIterator &other) const { return !(*this > other); }
             private:
                 T m_CurrentValue;
             };
             #endif // SCIQLOP_SQPITERATOR_H

core/include/Variable/VariableCacheStrategy.h +11 -8

             #ifndef SCIQLOP_VARIABLECACHESTRATEGY_H
             #define SCIQLOP_VARIABLECACHESTRATEGY_H
             #include "CoreGlobal.h"
             #include <QLoggingCategory>
             #include <QObject>
             #include <Data/SqpRange.h>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             #include <utility>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheStrategy)
             class Variable;
             /**
              * Possible types of zoom operation
              */
-            // enum class CacheStrategy { FixedTolerance, TwoThreashold };
+            enum class CacheStrategy { FixedTolerance, TwoThreashold };
             /// This class aims to hande the cache strategy.
-            class SCIQLOP_CORE_EXPORT VariableCacheStrategy {
+            class SCIQLOP_CORE_EXPORT VariableCacheStrategy : public QObject {
+                Q_OBJECT
             public:
-                virtual std::pair<SqpRange, SqpRange> computeRange(const SqpRange &vRange,
+                explicit VariableCacheStrategy(QObject *parent = 0);
-                                                                   const SqpRange &rangeRequested)
-                    = 0;
-            };
+                std::pair<SqpRange, SqpRange> computeStrategyRanges(const SqpRange &vRange,
+                                                                    const SqpRange &rangeRequested);
+            private:
+                class VariableCacheStrategyPrivate;
+                spimpl::unique_impl_ptr<VariableCacheStrategyPrivate> impl;
+            };
             #endif // SCIQLOP_VARIABLECACHESTRATEGY_H

core/src/Data/DataSeriesIterator.cpp +1 0

             #include "Data/DataSeriesIterator.h"
             DataSeriesIteratorValue::DataSeriesIteratorValue(
                 std::unique_ptr<DataSeriesIteratorValue::Impl> impl)
                     : m_Impl{std::move(impl)}
             {
             }
             DataSeriesIteratorValue::DataSeriesIteratorValue(const DataSeriesIteratorValue &other)
                     : m_Impl{other.m_Impl->clone()}
             {
             }
             DataSeriesIteratorValue &DataSeriesIteratorValue::operator=(DataSeriesIteratorValue other)
             {
                 m_Impl->swap(*other.m_Impl);
                 return *this;
             }
             int DataSeriesIteratorValue::distance(const DataSeriesIteratorValue &other) const
             {
+                auto dist = m_Impl->distance(*other.m_Impl);
                 return m_Impl->distance(*other.m_Impl);
             }
             bool DataSeriesIteratorValue::equals(const DataSeriesIteratorValue &other) const
             {
                 return m_Impl->equals(*other.m_Impl);
             }
             bool DataSeriesIteratorValue::lowerThan(const DataSeriesIteratorValue &other) const
             {
                 return m_Impl->lowerThan(*other.m_Impl);
             }
             DataSeriesIteratorValue DataSeriesIteratorValue::advance(int offset) const
             {
                 return DataSeriesIteratorValue{m_Impl->advance(offset)};
             }
             void DataSeriesIteratorValue::next(int offset)
             {
                 m_Impl->next(offset);
             }
             void DataSeriesIteratorValue::prev()
             {
                 m_Impl->prev();
             }
             double DataSeriesIteratorValue::x() const
             {
                 return m_Impl->x();
             }
             double DataSeriesIteratorValue::value() const
             {
                 return m_Impl->value();
             }
             double DataSeriesIteratorValue::value(int componentIndex) const
             {
                 return m_Impl->value(componentIndex);
             }
             double DataSeriesIteratorValue::minValue() const
             {
                 return m_Impl->minValue();
             }
             double DataSeriesIteratorValue::maxValue() const
             {
                 return m_Impl->maxValue();
             }
             QVector<double> DataSeriesIteratorValue::values() const
             {
                 return m_Impl->values();
             }
             DataSeriesIteratorValue::Impl *DataSeriesIteratorValue::impl()
             {
                 return m_Impl.get();
             }

core/src/Data/VectorSeries.cpp +8 -5

             #include "Data/VectorSeries.h"
             namespace {
             /**
              * Flatten the three components of a vector to a single QVector that can be passed to an ArrayData
              *
              * Example:
              * xValues = {1, 2, 3}
              * yValues = {4, 5, 6}
              * zValues = {7, 8, 9}
              *
              * result = {1, 4, 7, 2, 5, 8, 3, 6, 9}
              *
              * @param xValues the x-component values of the vector
              * @param yValues the y-component values of the vector
              * @param zValues the z-component values of the vector
              * @return the single QVector
              * @remarks the three components are consumed
              * @sa ArrayData
              */
             std::vector<double> flatten(std::vector<double> xValues, std::vector<double> yValues,
                                         std::vector<double> zValues)
             {
                 if (xValues.size() != yValues.size() || xValues.size() != zValues.size()) {
                     /// @todo ALX : log
                     return {};
                 }
                 auto result = std::vector<double>();
                 result.reserve(xValues.size() * 3);
                 while (!xValues.empty()) {
                     result.insert(result.cend(), {xValues.front(), yValues.front(), zValues.front()});
                     xValues.erase(xValues.begin());
                     yValues.erase(yValues.begin());
                     zValues.erase(zValues.begin());
                 }
                 return result;
             }
             } // namespace
             VectorSeries::VectorSeries(std::vector<double> xAxisData, std::vector<double> xValuesData,
                                        std::vector<double> yValuesData, std::vector<double> zValuesData,
                                        const Unit &xAxisUnit, const Unit &valuesUnit)
                     : VectorSeries{std::move(xAxisData), flatten(std::move(xValuesData), std::move(yValuesData),
                                                                  std::move(zValuesData)),
                                    xAxisUnit, valuesUnit}
             {
             }
             VectorSeries::VectorSeries(std::vector<double> xAxisData, std::vector<double> valuesData,
                                        const Unit &xAxisUnit, const Unit &valuesUnit)
                     : DataSeries{std::make_shared<ArrayData<1> >(std::move(xAxisData)), xAxisUnit,
                                  std::make_shared<ArrayData<2> >(std::move(valuesData), 3), valuesUnit}
             {
             }
             std::unique_ptr<IDataSeries> VectorSeries::clone() const
             {
                 return std::make_unique<VectorSeries>(*this);
             }
             std::shared_ptr<IDataSeries> VectorSeries::subDataSeries(const SqpRange &range)
             {
                 auto subXAxisData = std::vector<double>();
-                auto subValuesData = std::vector<double>();
+                auto subXValuesData = std::vector<double>();
+                auto subYValuesData = std::vector<double>();
+                auto subZValuesData = std::vector<double>();
                 this->lockRead();
                 {
                     auto bounds = xAxisRange(range.m_TStart, range.m_TEnd);
                     for (auto it = bounds.first; it != bounds.second; ++it) {
                         subXAxisData.push_back(it->x());
-                        subValuesData.push_back(it->value(0));
+                        subXValuesData.push_back(it->value(0));
-                        subValuesData.push_back(it->value(1));
+                        subYValuesData.push_back(it->value(1));
-                        subValuesData.push_back(it->value(2));
+                        subZValuesData.push_back(it->value(2));
                     }
                 }
                 this->unlock();
-                return std::make_shared<VectorSeries>(std::move(subXAxisData), std::move(subValuesData),
+                return std::make_shared<VectorSeries>(std::move(subXAxisData), std::move(subXValuesData),
+                                                      std::move(subYValuesData), std::move(subZValuesData),
                                                       this->xAxisUnit(), this->valuesUnit());
             }

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

             #include <Variable/Variable.h>
             #include <Variable/VariableAcquisitionWorker.h>
             #include <Variable/VariableCacheStrategy.h>
-            #include <Variable/VariableCacheStrategyFactory.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Variable/VariableSynchronizationGroup.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Data/VariableRequest.h>
             #include <Time/TimeController.h>
             #include <QMutex>
             #include <QThread>
             #include <QUuid>
             #include <QtCore/QItemSelectionModel>
             #include <deque>
             #include <set>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,
                                                   const SqpRange &oldGraphRange)
             {
                 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                 auto varRangeRequested = varRange;
                 switch (zoomType) {
                     case AcquisitionZoomType::ZoomIn: {
                         auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                         auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaLeft;
                         varRangeRequested.m_TEnd -= deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::ZoomOut: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart -= deltaLeft;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanRight: {
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaRight;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanLeft: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         varRangeRequested.m_TStart -= deltaLeft;
                         varRangeRequested.m_TEnd -= deltaLeft;
                         break;
                     }
                     case AcquisitionZoomType::Unknown: {
                         qCCritical(LOG_VariableController())
                             << VariableController::tr("Impossible to synchronize: zoom type unknown");
                         break;
                     }
                     default:
                         qCCritical(LOG_VariableController()) << VariableController::tr(
                             "Impossible to synchronize: zoom type not take into account");
                         // No action
                         break;
                 }
                 return varRangeRequested;
             }
             }
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
-                          // m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
+                          m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
-                          m_VariableCacheStrategy{VariableCacheStrategyFactory::createCacheStrategy(
-                              CacheStrategy::SingleThreshold)},
                           m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
                           q{parent}
                 {
                     m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);
                     m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");
                 }
                 virtual ~VariableControllerPrivate()
                 {
                     qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");
                     m_VariableAcquisitionWorkerThread.quit();
                     m_VariableAcquisitionWorkerThread.wait();
                 }
                 void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,
                                     QUuid varRequestId);
                 QVector<SqpRange> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
                                                                 const SqpRange &dateTime);
                 std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
                 std::shared_ptr<IDataSeries>
                 retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);
                 void registerProvider(std::shared_ptr<IDataProvider> provider);
                 void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);
                 QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);
                 void updateVariableRequest(QUuid varRequestId);
                 void cancelVariableRequest(QUuid varRequestId);
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
                 std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
                 QThread m_VariableAcquisitionWorkerThread;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
                 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
                 std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >
                     m_GroupIdToVariableSynchronizationGroupMap;
                 std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
                 std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
                 std::map<QUuid, std::map<QUuid, VariableRequest> > m_VarRequestIdToVarIdVarRequestMap;
                 std::map<QUuid, std::deque<QUuid> > m_VarIdToVarRequestIdQueueMap;
                 VariableController *q;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
                 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
                         &VariableController::onAbortProgressRequested);
                 connect(impl->m_VariableAcquisitionWorker.get(),
                         &VariableAcquisitionWorker::variableCanceledRequested, this,
                         &VariableController::onAbortAcquisitionRequested);
                 connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,
                         &VariableController::onDataProvided);
                 connect(impl->m_VariableAcquisitionWorker.get(),
                         &VariableAcquisitionWorker::variableRequestInProgress, this,
                         &VariableController::onVariableRetrieveDataInProgress);
                 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,
                         impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);
                 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,
                         impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::finalize);
                 impl->m_VariableAcquisitionWorkerThread.start();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
             QItemSelectionModel *VariableController::variableSelectionModel() noexcept
             {
                 return impl->m_VariableSelectionModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             std::shared_ptr<Variable>
             VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (impl->m_VariableModel->containsVariable(variable)) {
                     // Clones variable
                     auto duplicate = variable->clone();
                     // Adds clone to model
                     impl->m_VariableModel->addVariable(duplicate);
                     // Generates clone identifier
                     impl->m_VariableToIdentifierMap[duplicate] = QUuid::createUuid();
                     // Registers provider
                     auto variableProvider = impl->m_VariableToProviderMap.at(variable);
                     auto duplicateProvider = variableProvider != nullptr ? variableProvider->clone() : nullptr;
                     impl->m_VariableToProviderMap[duplicate] = duplicateProvider;
                     if (duplicateProvider) {
                         impl->registerProvider(duplicateProvider);
                     }
                     return duplicate;
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Can't create duplicate of variable %1: variable not registered in the model")
                                .arg(variable->name());
                     return nullptr;
                 }
             }
             void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
                     return;
                 }
                 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
                 // make some treatments before the deletion
                 emit variableAboutToBeDeleted(variable);
                 // Deletes identifier
                 impl->m_VariableToIdentifierMap.erase(variable);
                 // Deletes provider
                 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
                 qCDebug(LOG_VariableController())
                     << tr("Number of providers deleted for variable %1: %2")
                            .arg(variable->name(), QString::number(nbProvidersDeleted));
                 // Deletes from model
                 impl->m_VariableModel->deleteVariable(variable);
             }
             void VariableController::deleteVariables(
                 const QVector<std::shared_ptr<Variable> > &variables) noexcept
             {
                 for (auto variable : qAsConst(variables)) {
                     deleteVariable(variable);
                 }
             }
             std::shared_ptr<Variable>
             VariableController::createVariable(const QString &name, const QVariantHash &metadata,
                                                std::shared_ptr<IDataProvider> provider) noexcept
             {
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return nullptr;
                 }
                 auto range = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {
                     auto identifier = QUuid::createUuid();
                     // store the provider
                     impl->registerProvider(provider);
                     // Associate the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     qCInfo(LOG_VariableController()) << "createVariable: " << identifier;
                     impl->m_VariableToIdentifierMap[newVariable] = identifier;
                     auto varRequestId = QUuid::createUuid();
                     impl->processRequest(newVariable, range, varRequestId);
                     impl->updateVariableRequest(varRequestId);
                     return newVariable;
                 }
             }
             void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
             {
                 // TODO check synchronisation and Rescale
                 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
                                                   << QThread::currentThread()->objectName();
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 auto varRequestId = QUuid::createUuid();
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
                         selectedVariable->setRange(dateTime);
                         impl->processRequest(selectedVariable, dateTime, varRequestId);
                         // notify that rescale operation has to be done
                         emit rangeChanged(selectedVariable, dateTime);
                     }
                 }
                 impl->updateVariableRequest(varRequestId);
             }
             void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
                                                     const SqpRange &cacheRangeRequested,
                                                     QVector<AcquisitionDataPacket> dataAcquired)
             {
                 auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
                 auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);
                 if (!varRequestId.isNull()) {
                     impl->updateVariableRequest(varRequestId);
                 }
             }
             void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
             {
                 qCDebug(LOG_VariableController())
                     << "TORM: variableController::onVariableRetrieveDataInProgress"
                     << QThread::currentThread()->objectName() << progress;
                 if (auto var = impl->findVariable(identifier)) {
                     impl->m_VariableModel->setDataProgress(var, progress);
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to notify progression of a null variable");
                 }
             }
             void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
             {
                 auto it = impl->m_VariableToIdentifierMap.find(variable);
                 if (it != impl->m_VariableToIdentifierMap.cend()) {
                     impl->m_VariableAcquisitionWorker->abortProgressRequested(it->second);
                     QUuid varRequestId;
                     auto varIdToVarRequestIdQueueMapIt = impl->m_VarIdToVarRequestIdQueueMap.find(it->second);
                     if (varIdToVarRequestIdQueueMapIt != impl->m_VarIdToVarRequestIdQueueMap.cend()) {
                         auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
                         varRequestId = varRequestIdQueue.front();
                         impl->cancelVariableRequest(varRequestId);
                         // Finish the progression for the request
                         impl->m_VariableModel->setDataProgress(variable, 0.0);
                     }
                     else {
                         qCWarning(LOG_VariableController())
                             << tr("Aborting progression of inexistant variable request detected !!!")
                             << QThread::currentThread()->objectName();
                     }
                 }
                 else {
                     qCWarning(LOG_VariableController())
                         << tr("Aborting progression of inexistant variable detected !!!")
                         << QThread::currentThread()->objectName();
                 }
             }
             void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)
             {
                 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortAcquisitionRequested"
                                                   << QThread::currentThread()->objectName() << vIdentifier;
                 if (auto var = impl->findVariable(vIdentifier)) {
                     this->onAbortProgressRequested(var);
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to abort Acquisition Requestof a null variable");
                 }
             }
             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));
             }
             void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)
             {
                 impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);
             }
             void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
                                                        QUuid synchronizationGroupId)
             {
                 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
                                                   << synchronizationGroupId;
                 auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
                 if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
                     auto groupIdToVSGIt
                         = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
                     if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
                         impl->m_VariableIdGroupIdMap.insert(
                             std::make_pair(varToVarIdIt->second, synchronizationGroupId));
                         groupIdToVSGIt->second->addVariableId(varToVarIdIt->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::desynchronize(std::shared_ptr<Variable> variable,
                                                    QUuid synchronizationGroupId)
             {
                 // Gets variable id
                 auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
                 if (variableIt == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Can't desynchronize variable %1: variable identifier not found")
                                .arg(variable->name());
                     return;
                 }
                 // Gets synchronization group
                 auto groupIt = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
                 if (groupIt == impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Can't desynchronize variable %1: unknown synchronization group")
                                .arg(variable->name());
                     return;
                 }
                 auto variableId = variableIt->second;
                 // Removes variable from synchronization group
                 auto synchronizationGroup = groupIt->second;
                 synchronizationGroup->removeVariableId(variableId);
                 // Removes link between variable and synchronization group
                 impl->m_VariableIdGroupIdMap.erase(variableId);
             }
             void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
                                                           const SqpRange &range, const SqpRange &oldRange,
                                                           bool synchronise)
             {
                 // NOTE: oldRange isn't really necessary since oldRange == variable->range().
                 // 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.
                 auto varRequestId = QUuid::createUuid();
                 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
                                                   << QThread::currentThread()->objectName() << varRequestId;
                 for (const auto &var : variables) {
                     qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId;
                     impl->processRequest(var, range, varRequestId);
                 }
                 if (synchronise) {
                     // Get the group ids
                     qCDebug(LOG_VariableController())
                         << "TORM VariableController::onRequestDataLoading for synchro var ENABLE";
                     auto groupIds = std::set<QUuid>{};
                     auto groupIdToOldRangeMap = std::map<QUuid, SqpRange>{};
                     for (const auto &var : variables) {
                         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;
                                 groupIdToOldRangeMap.insert(std::make_pair(gId, var->range()));
                                 if (groupIds.find(gId) == groupIds.cend()) {
                                     qCDebug(LOG_VariableController()) << "Synchro detect group " << gId;
                                     groupIds.insert(gId);
                                 }
                             }
                         }
                     }
                     // We assume here all group ids exist
                     for (const 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);
                             // 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, groupIdToOldRangeMap.at(gId));
                                     qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
                                     impl->processRequest(var, vSyncRangeRequested, varRequestId);
                                 }
                                 else {
                                     qCCritical(LOG_VariableController())
                                         << tr("Impossible to synchronize a null variable");
                                 }
                             }
                         }
                     }
                 }
                 impl->updateVariableRequest(varRequestId);
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }
             AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
             {
                 // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
                 auto zoomType = AcquisitionZoomType::Unknown;
                 if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
                     zoomType = AcquisitionZoomType::ZoomOut;
                 }
                 else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
                     zoomType = AcquisitionZoomType::PanRight;
                 }
                 else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
                     zoomType = AcquisitionZoomType::PanLeft;
                 }
                 else if (range.m_TStart > oldRange.m_TStart && oldRange.m_TEnd > range.m_TEnd) {
                     zoomType = AcquisitionZoomType::ZoomIn;
                 }
                 else {
                     qCCritical(LOG_VariableController()) << "getZoomType: Unknown type detected";
                 }
                 return zoomType;
             }
             void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
                                                                                const SqpRange &rangeRequested,
                                                                                QUuid varRequestId)
             {
                 // TODO: protect at
                 auto varRequest = VariableRequest{};
                 auto varId = m_VariableToIdentifierMap.at(var);
                 auto varStrategyRangesRequested
-                    = m_VariableCacheStrategy->computeRange(var->range(), rangeRequested);
+                    = m_VariableCacheStrategy->computeStrategyRanges(var->range(), rangeRequested);
+                auto notInCacheRangeList = var->provideNotInCacheRangeList(varStrategyRangesRequested.second);
-                auto notInCacheRangeList = QVector<SqpRange>{varStrategyRangesRequested.second};
+                auto inCacheRangeList = var->provideInCacheRangeList(varStrategyRangesRequested.second);
-                auto inCacheRangeList = QVector<SqpRange>{};
-                if (m_VarIdToVarRequestIdQueueMap.find(varId) == m_VarIdToVarRequestIdQueueMap.cend()) {
-                    notInCacheRangeList = var->provideNotInCacheRangeList(varStrategyRangesRequested.second);
-                    inCacheRangeList = var->provideInCacheRangeList(varStrategyRangesRequested.second);
                 if (!notInCacheRangeList.empty()) {
                     varRequest.m_RangeRequested = varStrategyRangesRequested.first;
                     varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
                     // store VarRequest
                     storeVariableRequest(varId, varRequestId, varRequest);
                     auto varProvider = m_VariableToProviderMap.at(var);
                     if (varProvider != nullptr) {
                         auto varRequestIdCanceled = m_VariableAcquisitionWorker->pushVariableRequest(
                             varRequestId, varId, varStrategyRangesRequested.first,
                             varStrategyRangesRequested.second,
                             DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
                             varProvider);
                         if (!varRequestIdCanceled.isNull()) {
                             qCDebug(LOG_VariableAcquisitionWorker()) << tr("vsarRequestIdCanceled: ")
                                                                      << varRequestIdCanceled;
                             cancelVariableRequest(varRequestIdCanceled);
                         }
                     }
                     else {
                         qCCritical(LOG_VariableController())
                             << "Impossible to provide data with a null provider";
                     }
                     if (!inCacheRangeList.empty()) {
                         emit q->updateVarDisplaying(var, inCacheRangeList.first());
                     }
                 }
                 else {
                     varRequest.m_RangeRequested = varStrategyRangesRequested.first;
                     varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
                     // store VarRequest
                     storeVariableRequest(varId, varRequestId, varRequest);
                     acceptVariableRequest(varId,
                                           var->dataSeries()->subDataSeries(varStrategyRangesRequested.second));
                 }
             }
             std::shared_ptr<Variable>
             VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
             {
                 std::shared_ptr<Variable> var;
                 auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
                 auto end = m_VariableToIdentifierMap.cend();
                 auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
                 if (it != end) {
                     var = it->first;
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to find the variable with the identifier: ") << vIdentifier;
                 }
                 return var;
             }
             std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
                 const QVector<AcquisitionDataPacket> acqDataPacketVector)
             {
                 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
                                                   << acqDataPacketVector.size();
                 std::shared_ptr<IDataSeries> dataSeries;
                 if (!acqDataPacketVector.isEmpty()) {
                     dataSeries = acqDataPacketVector[0].m_DateSeries;
                     for (int i = 1; i < acqDataPacketVector.size(); ++i) {
                         dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
                     }
                 }
                 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
                                                   << acqDataPacketVector.size();
                 return dataSeries;
             }
             void VariableController::VariableControllerPrivate::registerProvider(
                 std::shared_ptr<IDataProvider> provider)
             {
                 if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
                     qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
                                                       << provider->objectName();
                     m_ProviderSet.insert(provider);
                     connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableDataAcquired);
                     connect(provider.get(), &IDataProvider::dataProvidedProgress,
                             m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
                     connect(provider.get(), &IDataProvider::dataProvidedFailed,
                             m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableAcquisitionFailed);
                 }
                 else {
                     qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
                 }
             }
             void VariableController::VariableControllerPrivate::storeVariableRequest(
                 QUuid varId, QUuid varRequestId, const VariableRequest &varRequest)
             {
                 // First request for the variable. we can create an entry for it
                 auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.find(varId);
                 if (varIdToVarRequestIdQueueMapIt == m_VarIdToVarRequestIdQueueMap.cend()) {
                     auto varRequestIdQueue = std::deque<QUuid>{};
                     qCDebug(LOG_VariableController()) << tr("Store REQUEST in  QUEUE");
                     varRequestIdQueue.push_back(varRequestId);
                     m_VarIdToVarRequestIdQueueMap.insert(std::make_pair(varId, std::move(varRequestIdQueue)));
                 }
                 else {
                     qCDebug(LOG_VariableController()) << tr("Store REQUEST in EXISTING QUEUE");
                     auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
                     varRequestIdQueue.push_back(varRequestId);
                 }
                 auto varRequestIdToVarIdVarRequestMapIt = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
                 if (varRequestIdToVarIdVarRequestMapIt == m_VarRequestIdToVarIdVarRequestMap.cend()) {
                     auto varIdToVarRequestMap = std::map<QUuid, VariableRequest>{};
                     varIdToVarRequestMap.insert(std::make_pair(varId, varRequest));
                     qCDebug(LOG_VariableController()) << tr("Store REQUESTID in MAP");
                     m_VarRequestIdToVarIdVarRequestMap.insert(
                         std::make_pair(varRequestId, std::move(varIdToVarRequestMap)));
                 }
                 else {
                     auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
                     qCDebug(LOG_VariableController()) << tr("Store REQUESTID in EXISTING MAP");
                     varIdToVarRequestMap.insert(std::make_pair(varId, varRequest));
                 }
             }
             QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
                 QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
             {
                 QUuid varRequestId;
                 auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.find(varId);
                 if (varIdToVarRequestIdQueueMapIt != m_VarIdToVarRequestIdQueueMap.cend()) {
                     auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
                     varRequestId = varRequestIdQueue.front();
                     auto varRequestIdToVarIdVarRequestMapIt
                         = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
                     if (varRequestIdToVarIdVarRequestMapIt != m_VarRequestIdToVarIdVarRequestMap.cend()) {
                         auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
                         auto varIdToVarRequestMapIt = varIdToVarRequestMap.find(varId);
                         if (varIdToVarRequestMapIt != varIdToVarRequestMap.cend()) {
                             qCDebug(LOG_VariableController()) << tr("acceptVariableRequest");
                             auto &varRequest = varIdToVarRequestMapIt->second;
                             varRequest.m_DataSeries = dataSeries;
                             varRequest.m_CanUpdate = true;
                         }
                         else {
                             qCDebug(LOG_VariableController())
                                 << tr("Impossible to acceptVariableRequest of a unknown variable id attached "
                                       "to a variableRequestId")
                                 << varRequestId << varId;
                         }
                     }
                     else {
                         qCCritical(LOG_VariableController())
                             << tr("Impossible to acceptVariableRequest of a unknown variableRequestId")
                             << varRequestId;
                     }
                     varRequestIdQueue.pop_front();
                     if (varRequestIdQueue.empty()) {
                         qCDebug(LOG_VariableController())
                             << tr("TORM Erase REQUEST because it has been accepted") << varId;
                         m_VarIdToVarRequestIdQueueMap.erase(varId);
                     }
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to acceptVariableRequest of a unknown variable id") << varId;
                 }
                 return varRequestId;
             }
             void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)
             {
                 auto varRequestIdToVarIdVarRequestMapIt = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
                 if (varRequestIdToVarIdVarRequestMapIt != m_VarRequestIdToVarIdVarRequestMap.cend()) {
                     bool processVariableUpdate = true;
                     auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
                     for (auto varIdToVarRequestMapIt = varIdToVarRequestMap.cbegin();
                          (varIdToVarRequestMapIt != varIdToVarRequestMap.cend()) && processVariableUpdate;
                          ++varIdToVarRequestMapIt) {
                         processVariableUpdate &= varIdToVarRequestMapIt->second.m_CanUpdate;
                         qCDebug(LOG_VariableController()) << tr("updateVariableRequest")
                                                           << processVariableUpdate;
                     }
                     if (processVariableUpdate) {
                         for (auto varIdToVarRequestMapIt = varIdToVarRequestMap.cbegin();
                              varIdToVarRequestMapIt != varIdToVarRequestMap.cend(); ++varIdToVarRequestMapIt) {
                             if (auto var = findVariable(varIdToVarRequestMapIt->first)) {
                                 auto &varRequest = varIdToVarRequestMapIt->second;
                                 var->setRange(varRequest.m_RangeRequested);
                                 var->setCacheRange(varRequest.m_CacheRangeRequested);
                                 qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
                                                                   << varRequest.m_RangeRequested;
                                 qCDebug(LOG_VariableController()) << tr("2: onDataProvided")
                                                                   << varRequest.m_CacheRangeRequested;
                                 var->mergeDataSeries(varRequest.m_DataSeries);
                                 qCDebug(LOG_VariableController()) << tr("3: onDataProvided")
                                                                   << varRequest.m_DataSeries->range();
                                 qCDebug(LOG_VariableController()) << tr("4: onDataProvided");
                                 /// @todo MPL: confirm
                                 // Variable update is notified only if there is no pending request for it
                                 //                    if
                                 //                    (m_VarIdToVarRequestIdQueueMap.count(varIdToVarRequestMapIt->first)
                                 //                    == 0) {
                                 emit var->updated();
                                 //                    }
                             }
                             else {
                                 qCCritical(LOG_VariableController())
                                     << tr("Impossible to update data to a null variable");
                             }
                         }
                         // cleaning varRequestId
                         qCDebug(LOG_VariableController()) << tr("0: erase REQUEST in  MAP ?")
                                                           << m_VarRequestIdToVarIdVarRequestMap.size();
                         m_VarRequestIdToVarIdVarRequestMap.erase(varRequestId);
                         qCDebug(LOG_VariableController()) << tr("1: erase REQUEST in  MAP ?")
                                                           << m_VarRequestIdToVarIdVarRequestMap.size();
                     }
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Cannot updateVariableRequest for a unknow varRequestId") << varRequestId;
                 }
             }
             void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)
             {
                 // cleaning varRequestId
                 m_VarRequestIdToVarIdVarRequestMap.erase(varRequestId);
                 for (auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.begin();
                      varIdToVarRequestIdQueueMapIt != m_VarIdToVarRequestIdQueueMap.end();) {
                     auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
                     varRequestIdQueue.erase(
                         std::remove(varRequestIdQueue.begin(), varRequestIdQueue.end(), varRequestId),
                         varRequestIdQueue.end());
                     if (varRequestIdQueue.empty()) {
                         varIdToVarRequestIdQueueMapIt
                             = m_VarIdToVarRequestIdQueueMap.erase(varIdToVarRequestIdQueueMapIt);
                     }
                     else {
                         ++varIdToVarRequestIdQueueMapIt;
                     }
                 }
             }

core/tests/meson.build +1 -2

             tests = [
               [['Common/TestStringUtils.cpp'],'test_string_utils','StringUtils test'],
               [['Data/TestDataSeries.cpp'],'test_data','DataSeries test'],
               [['Data/TestOneDimArrayData.cpp'],'test_1d','One Dim Array test'],
               [['Data/TestTwoDimArrayData.cpp'],'test_2d','Two Dim Array test'],
               [['DataSource/TestDataSourceController.cpp'],'test_data_source','DataSourceController test'],
               [['Variable/TestVariableCacheController.cpp'],'test_variable_cache','VariableCacheController test'],
-              [['Variable/TestVariable.cpp'],'test_variable','Variable test'],
+              [['Variable/TestVariable.cpp'],'test_variable','Variable test']
-              [['Variable/TestVariableSync.cpp'],'test_variable_sync','Variable synchronization test']
             ]
             foreach unit_test : tests
               test_moc_files = qt5.preprocess(moc_sources : unit_test[0])
               test_exe = executable(unit_test[1],unit_test[0] , test_moc_files,
                                       dependencies : [sciqlop_core, qt5test])
               test(unit_test[2], test_exe, args: ['-teamcity', '-o', '@0@.teamcity.txt'.format(unit_test[1])])
             endforeach

gui/include/Variable/RenameVariableDialog.h 0 -1

             #ifndef SCIQLOP_RENAMEVARIABLEDIALOG_H
             #define SCIQLOP_RENAMEVARIABLEDIALOG_H
             #include <QDialog>
             namespace Ui {
             class RenameVariableDialog;
             } // Ui
             /**
              * @brief The RenameVariableDialog class represents the dialog to rename a variable
              */
             class RenameVariableDialog : public QDialog {
-                Q_OBJECT
             public:
                 explicit RenameVariableDialog(const QString &defaultName,
                                               const QVector<QString> &forbiddenNames,
                                               QWidget *parent = nullptr);
                 virtual ~RenameVariableDialog() noexcept;
                 QString name() const noexcept;
             public slots:
                 void accept() override;
             private:
                 Ui::RenameVariableDialog *ui;
                 QString m_DefaultName;
                 QVector<QString> m_ForbiddenNames;
             };
             #endif // SCIQLOP_RENAMEVARIABLEDIALOG_H

gui/meson.build 0 -3

             gui_moc_headers = [
               'include/DataSource/DataSourceWidget.h',
               'include/Settings/SqpSettingsDialog.h',
               'include/Settings/SqpSettingsGeneralWidget.h',
               'include/SidePane/SqpSidePane.h',
               'include/SqpApplication.h',
               'include/TimeWidget/TimeWidget.h',
               'include/Variable/VariableInspectorWidget.h',
-              'include/Variable/RenameVariableDialog.h',
               'include/Visualization/qcustomplot.h',
               'include/Visualization/VisualizationGraphWidget.h',
               'include/Visualization/VisualizationTabWidget.h',
               'include/Visualization/VisualizationWidget.h',
               'include/Visualization/VisualizationZoneWidget.h'
             ]
             gui_ui_files = [
               'ui/DataSource/DataSourceWidget.ui',
               'ui/Settings/SqpSettingsDialog.ui',
               'ui/Settings/SqpSettingsGeneralWidget.ui',
               'ui/SidePane/SqpSidePane.ui',
               'ui/TimeWidget/TimeWidget.ui',
               'ui/Variable/VariableInspectorWidget.ui',
-              'ui/Variable/RenameVariableDialog.ui',
               'ui/Variable/VariableMenuHeaderWidget.ui',
               'ui/Visualization/VisualizationGraphWidget.ui',
               'ui/Visualization/VisualizationTabWidget.ui',
               'ui/Visualization/VisualizationWidget.ui',
               'ui/Visualization/VisualizationZoneWidget.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files,
                                            qresources : gui_qresources)
             gui_sources = [
               'src/SqpApplication.cpp',
               'src/Common/ColorUtils.cpp',
               'src/DataSource/DataSourceTreeWidgetItem.cpp',
               'src/DataSource/DataSourceTreeWidgetHelper.cpp',
               'src/DataSource/DataSourceWidget.cpp',
               'src/Settings/SqpSettingsDialog.cpp',
               'src/Settings/SqpSettingsGeneralWidget.cpp',
               'src/SidePane/SqpSidePane.cpp',
               'src/TimeWidget/TimeWidget.cpp',
               'src/Variable/VariableInspectorWidget.cpp',
               'src/Variable/VariableMenuHeaderWidget.cpp',
-              'src/Variable/RenameVariableDialog.cpp',
               'src/Visualization/VisualizationGraphHelper.cpp',
               'src/Visualization/VisualizationGraphRenderingDelegate.cpp',
               'src/Visualization/VisualizationGraphWidget.cpp',
               'src/Visualization/VisualizationTabWidget.cpp',
               'src/Visualization/VisualizationWidget.cpp',
               'src/Visualization/VisualizationZoneWidget.cpp',
               'src/Visualization/qcustomplot.cpp',
               'src/Visualization/QCustomPlotSynchronizer.cpp',
               'src/Visualization/operations/FindVariableOperation.cpp',
               'src/Visualization/operations/GenerateVariableMenuOperation.cpp',
               'src/Visualization/operations/MenuBuilder.cpp',
               'src/Visualization/operations/RemoveVariableOperation.cpp',
               'src/Visualization/operations/RescaleAxeOperation.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core])

gui/src/Variable/VariableInspectorWidget.cpp +15 -26

             #include <Variable/RenameVariableDialog.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableInspectorWidget.h>
             #include <Variable/VariableMenuHeaderWidget.h>
             #include <Variable/VariableModel.h>
             #include <ui_VariableInspectorWidget.h>
             #include <QMouseEvent>
             #include <QSortFilterProxyModel>
             #include <QStyledItemDelegate>
             #include <QWidgetAction>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_VariableInspectorWidget, "VariableInspectorWidget")
             class QProgressBarItemDelegate : public QStyledItemDelegate {
             public:
                 QProgressBarItemDelegate(QObject *parent) : QStyledItemDelegate{parent} {}
                 void paint(QPainter *painter, const QStyleOptionViewItem &option,
                            const QModelIndex &index) const
                 {
                     auto data = index.data(Qt::DisplayRole);
                     auto progressData = index.data(VariableRoles::ProgressRole);
                     if (data.isValid() && progressData.isValid()) {
                         auto name = data.value<QString>();
                         auto progress = progressData.value<double>();
                         if (progress > 0) {
                             auto cancelButtonWidth = 20;
                             auto progressBarOption = QStyleOptionProgressBar{};
                             auto progressRect = option.rect;
                             progressRect.setWidth(progressRect.width() - cancelButtonWidth);
                             progressBarOption.rect = progressRect;
                             progressBarOption.minimum = 0;
                             progressBarOption.maximum = 100;
                             progressBarOption.progress = progress;
                             progressBarOption.text
                                 = QString("%1 %2").arg(name).arg(QString::number(progress, 'f', 2) + "%");
                             progressBarOption.textVisible = true;
                             progressBarOption.textAlignment = Qt::AlignCenter;
                             QApplication::style()->drawControl(QStyle::CE_ProgressBar, &progressBarOption,
                                                                painter);
                             // Cancel button
                             auto buttonRect = QRect(progressRect.right(), option.rect.top(), cancelButtonWidth,
                                                     option.rect.height());
                             auto buttonOption = QStyleOptionButton{};
                             buttonOption.rect = buttonRect;
                             buttonOption.text = "X";
                             QApplication::style()->drawControl(QStyle::CE_PushButton, &buttonOption, painter);
                         }
                         else {
                             QStyledItemDelegate::paint(painter, option, index);
                         }
                     }
                     else {
                         QStyledItemDelegate::paint(painter, option, index);
                     }
                 }
                 bool editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option,
                                  const QModelIndex &index)
                 {
                     if (event->type() == QEvent::MouseButtonRelease) {
                         auto data = index.data(Qt::DisplayRole);
                         auto progressData = index.data(VariableRoles::ProgressRole);
                         if (data.isValid() && progressData.isValid()) {
                             auto cancelButtonWidth = 20;
                             auto progressRect = option.rect;
                             progressRect.setWidth(progressRect.width() - cancelButtonWidth);
                             // Cancel button
                             auto buttonRect = QRect(progressRect.right(), option.rect.top(), cancelButtonWidth,
                                                     option.rect.height());
                             auto e = (QMouseEvent *)event;
                             auto clickX = e->x();
                             auto clickY = e->y();
                             auto x = buttonRect.left();   // the X coordinate
                             auto y = buttonRect.top();    // the Y coordinate
                             auto w = buttonRect.width();  // button width
                             auto h = buttonRect.height(); // button height
                             if (clickX > x && clickX < x + w) {
                                 if (clickY > y && clickY < y + h) {
                                     auto variableModel = sqpApp->variableController().variableModel();
                                     variableModel->abortProgress(index);
                                 }
-                                return true;
                             }
                             else {
-                                return QStyledItemDelegate::editorEvent(event, model, option, index);
+                                QStyledItemDelegate::editorEvent(event, model, option, index);
                             }
                         }
                         else {
-                            return QStyledItemDelegate::editorEvent(event, model, option, index);
+                            QStyledItemDelegate::editorEvent(event, model, option, index);
                         }
                     }
                     else {
-                        return QStyledItemDelegate::editorEvent(event, model, option, index);
+                        QStyledItemDelegate::editorEvent(event, model, option, index);
                     }
-                    return QStyledItemDelegate::editorEvent(event, model, option, index);
                 }
             };
             VariableInspectorWidget::VariableInspectorWidget(QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VariableInspectorWidget},
                       m_ProgressBarItemDelegate{new QProgressBarItemDelegate{this}}
             {
                 ui->setupUi(this);
                 // Sets model for table
                 //    auto sortFilterModel = new QSortFilterProxyModel{this};
                 //    sortFilterModel->setSourceModel(sqpApp->variableController().variableModel());
                 auto variableModel = sqpApp->variableController().variableModel();
                 ui->tableView->setModel(variableModel);
                 // Adds extra signal/slot between view and model, so the view can be updated instantly when
                 // there is a change of data in the model
                 connect(variableModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this,
                         SLOT(refresh()));
                 ui->tableView->setSelectionModel(sqpApp->variableController().variableSelectionModel());
                 ui->tableView->setItemDelegateForColumn(0, m_ProgressBarItemDelegate);
                 // Fixes column sizes
                 auto model = ui->tableView->model();
                 const auto count = model->columnCount();
                 for (auto i = 0; i < count; ++i) {
                     ui->tableView->setColumnWidth(
                         i, model->headerData(i, Qt::Horizontal, Qt::SizeHintRole).toSize().width());
                 }
                 // Sets selection options
                 ui->tableView->setSelectionBehavior(QTableView::SelectRows);
                 ui->tableView->setSelectionMode(QTableView::ExtendedSelection);
                 // Connection to show a menu when right clicking on the tree
                 ui->tableView->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->tableView, &QTableView::customContextMenuRequested, this,
                         &VariableInspectorWidget::onTableMenuRequested);
             }
             VariableInspectorWidget::~VariableInspectorWidget()
             {
                 delete ui;
             }
             void VariableInspectorWidget::onTableMenuRequested(const QPoint &pos) noexcept
             {
                 auto selectedRows = ui->tableView->selectionModel()->selectedRows();
                 // Gets the model to retrieve the underlying selected variables
                 auto model = sqpApp->variableController().variableModel();
                 auto selectedVariables = QVector<std::shared_ptr<Variable> >{};
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = model->variable(selectedRow.row())) {
                         selectedVariables.push_back(selectedVariable);
                     }
                 }
                 QMenu tableMenu{};
                 // Emits a signal so that potential receivers can populate the menu before displaying it
                 emit tableMenuAboutToBeDisplayed(&tableMenu, selectedVariables);
                 // Adds menu-specific actions
                 if (!selectedVariables.isEmpty()) {
                     tableMenu.addSeparator();
                     // 'Rename' and 'Duplicate' actions (only if one variable selected)
                     if (selectedVariables.size() == 1) {
                         auto selectedVariable = selectedVariables.front();
-                        auto duplicateFun = [varW = std::weak_ptr<Variable>(selectedVariable)]()
+                        auto duplicateFun = [&selectedVariable]() {
+                            sqpApp->variableController().cloneVariable(selectedVariable);
-                            if (auto var = varW.lock()) {
-                                sqpApp->variableController().cloneVariable(var);
                         };
                         tableMenu.addAction(tr("Duplicate"), duplicateFun);
-                        auto renameFun = [ varW = std::weak_ptr<Variable>(selectedVariable), &model, this ]()
+                        auto renameFun = [&selectedVariable, &model, this]() {
+                            // Generates forbidden names (names associated to existing variables)
-                            if (auto var = varW.lock()) {
+                            auto allVariables = model->variables();
-                                // Generates forbidden names (names associated to existing variables)
+                            auto forbiddenNames = QVector<QString>(allVariables.size());
-                                auto allVariables = model->variables();
+                            std::transform(allVariables.cbegin(), allVariables.cend(), forbiddenNames.begin(),
-                                auto forbiddenNames = QVector<QString>(allVariables.size());
+                                           [](const auto &variable) { return variable->name(); });
-                                std::transform(allVariables.cbegin(), allVariables.cend(),
-                                               forbiddenNames.begin(),
+                            RenameVariableDialog dialog{selectedVariable->name(), forbiddenNames, this};
-                                               [](const auto &variable) { return variable->name(); });
+                            if (dialog.exec() == QDialog::Accepted) {
+                                selectedVariable->setName(dialog.name());
-                                RenameVariableDialog dialog{var->name(), forbiddenNames, this};
-                                if (dialog.exec() == QDialog::Accepted) {
-                                    var->setName(dialog.name());
                             }
                         };
                         tableMenu.addAction(tr("Rename..."), renameFun);
                     }
                     // 'Delete' action
                     auto deleteFun = [&selectedVariables]() {
                         sqpApp->variableController().deleteVariables(selectedVariables);
                     };
                     tableMenu.addAction(QIcon{":/icones/delete.png"}, tr("Delete"), deleteFun);
                 }
                 if (!tableMenu.isEmpty()) {
                     // Generates menu header (inserted before first action)
                     auto firstAction = tableMenu.actions().first();
                     auto headerAction = new QWidgetAction{&tableMenu};
                     headerAction->setDefaultWidget(new VariableMenuHeaderWidget{selectedVariables, &tableMenu});
                     tableMenu.insertAction(firstAction, headerAction);
                     // Displays menu
                     tableMenu.exec(QCursor::pos());
                 }
             }
             void VariableInspectorWidget::refresh() noexcept
             {
                 ui->tableView->viewport()->update();
             }

plugins/amda/meson.build +1 -2

             amdaplugin_moc_headers = [
-              'include/AmdaPlugin.h',
+              'include/AmdaPlugin.h'
-              'include/AmdaProvider.h'
             ]
             amdaplugin_sources = [
               'src/AmdaDefs.cpp',
               'src/AmdaParser.cpp',
               'src/AmdaPlugin.cpp',
               'src/AmdaProvider.cpp',
               'src/AmdaResultParser.cpp'
             ]
             amdaplugin_ui_files = []
             amdaplugin_resources_files = [
               'resources/amdaresources.qrc'
             ]
             amdaplugin_inc = include_directories(['include', '../../plugin/include'])
             moc_gen = generator(moc,
                             output  : 'moc_@BASENAME@.cpp',
                             arguments : ['@INPUT@',
                              '-DPLUGIN_JSON_FILE_PATH="'+meson.source_root()+'/plugins/amda/resources/amda.json"',
                              '-I', meson.current_source_dir()+'/include',
                              '-I', meson.current_source_dir()+'/../../plugin/include',
                              '-o', '@OUTPUT@'])
             rcc_gen = generator(rcc,
                             output  : 'qrc_@BASENAME@.cpp',
                             arguments : ['--name=@BASENAME@"',
                              '--output',
                              '@OUTPUT@',
                              '@INPUT@'])
             amdaplugin_moc_plugin_files = moc_gen.process(amdaplugin_moc_headers)
             amdaplugin_rcc_plugin_files = rcc_gen.process(amdaplugin_resources_files)
             #amdaplugin_rcc_plugin_files = qt5.preprocess(
             #                               qresources : amdaplugin_resources_files)
             amdaplugin_moc_files = qt5.preprocess(
                                            ui_files : amdaplugin_ui_files)
             sciqlop_amdaplugin = library('amdaplugin',
                                    amdaplugin_sources,
                                    amdaplugin_moc_files,
                                    amdaplugin_rcc_plugin_files,
                                    amdaplugin_moc_plugin_files,
                                    cpp_args : ['-DAMDA_LIB','-DQT_PLUGIN'],
                                    include_directories : [amdaplugin_inc],
                                    dependencies : [sciqlop_core, sciqlop_gui],
                                    install : true
                                    )
             tests = [
               [['tests/TestAmdaParser.cpp'],'test_amda_parser','AMDA parser test'],
               [['tests/TestAmdaResultParser.cpp'],'test_amda_result_parser','AMDA result parser test'],
               [['tests/TestAmdaAcquisition.cpp'],'test_amda_acquisition','AMDA Acquisition test']
             ]
             foreach unit_test : tests
               test_moc_files = qt5.preprocess(moc_sources : unit_test[0])
               test_exe = executable(unit_test[1],unit_test[0] , test_moc_files,
                                       link_with : [sciqlop_amdaplugin],
                                       include_directories : [amdaplugin_inc],
                                       cpp_args : ['-DAMDA_TESTS_RESOURCES_DIR="'+meson.current_source_dir()+'/tests-resources"'],
                                       dependencies : [sciqlop_core, sciqlop_gui, qt5test])
               test(unit_test[2], test_exe, args: ['-teamcity', '-o', '@0@.teamcity.txt'.format(unit_test[1])], timeout: 3 * 60)
             endforeach

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

             #include "AmdaProvider.h"
             #include "AmdaDefs.h"
             #include "AmdaResultParser.h"
             #include <Common/DateUtils.h>
             #include <Data/DataProviderParameters.h>
             #include <Network/NetworkController.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <QNetworkAccessManager>
             #include <QNetworkReply>
             #include <QTemporaryFile>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
             namespace {
             /// URL format for a request on AMDA server. The parameters are as follows:
             /// - %1: start date
             /// - %2: end date
             /// - %3: parameter id
-            /// Old url: http://amda.irap.omp.eu/php/rest/
             const auto AMDA_URL_FORMAT = QStringLiteral(
-                "http://amdatest.irap.omp.eu/php/rest/"
+                "http://amda.irap.omp.eu/php/rest/"
                 "getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&outputFormat=ASCII&"
                 "timeFormat=ISO8601&gzip=0");
             /// Dates format passed in the URL (e.g 2013-09-23T09:00)
             const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
             /// Formats a time to a date that can be passed in URL
             QString dateFormat(double sqpRange) noexcept
             {
                 auto dateTime = DateUtils::dateTime(sqpRange);
                 return dateTime.toString(AMDA_TIME_FORMAT);
             }
             AmdaResultParser::ValueType valueType(const QString &valueType)
             {
                 if (valueType == QStringLiteral("scalar")) {
                     return AmdaResultParser::ValueType::SCALAR;
                 }
                 else if (valueType == QStringLiteral("vector")) {
                     return AmdaResultParser::ValueType::VECTOR;
                 }
                 else {
                     return AmdaResultParser::ValueType::UNKNOWN;
                 }
             }
             } // namespace
             AmdaProvider::AmdaProvider()
             {
                 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     connect(this, SIGNAL(requestConstructed(std::shared_ptr<QNetworkRequest>, QUuid,
                                                             std::function<void(QNetworkReply *, QUuid)>)),
                             &networkController,
                             SLOT(onProcessRequested(std::shared_ptr<QNetworkRequest>, QUuid,
                                                     std::function<void(QNetworkReply *, QUuid)>)));
                     connect(&sqpApp->networkController(),
                             SIGNAL(replyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)),
                             this,
                             SLOT(onReplyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)));
                 }
             }
             std::shared_ptr<IDataProvider> AmdaProvider::clone() const
             {
                 // No copy is made in the clone
                 return std::make_shared<AmdaProvider>();
             }
             void AmdaProvider::requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters)
             {
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 const auto data = parameters.m_Data;
                 for (const auto &dateTime : qAsConst(times)) {
                     qCDebug(LOG_AmdaProvider()) << tr("TORM AmdaProvider::requestDataLoading ") << acqIdentifier
                                                 << dateTime;
                     this->retrieveData(acqIdentifier, dateTime, data);
                     // TORM when AMDA will support quick asynchrone request
                     QThread::msleep(1000);
                 }
             }
             void AmdaProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     networkController.onReplyCanceled(acqIdentifier);
                 }
             }
             void AmdaProvider::onReplyDownloadProgress(QUuid acqIdentifier,
                                                        std::shared_ptr<QNetworkRequest> networkRequest,
                                                        double progress)
             {
                 qCDebug(LOG_AmdaProvider()) << tr("onReplyDownloadProgress") << acqIdentifier
                                             << networkRequest.get() << progress;
                 auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                     // Update the progression for the current request
                     auto requestPtr = networkRequest;
                     auto findRequest = [requestPtr](const auto &entry) { return requestPtr == entry.first; };
                     auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                     auto requestProgressMapEnd = requestProgressMap.end();
                     auto requestProgressMapIt
                         = std::find_if(requestProgressMap.begin(), requestProgressMapEnd, findRequest);
                     if (requestProgressMapIt != requestProgressMapEnd) {
                         requestProgressMapIt->second = progress;
                     }
                     else {
                         // This case can happened when a progression is send after the request has been
                         // finished.
                         // Generaly the case when aborting a request
                         qCDebug(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress") << acqIdentifier
                                                     << networkRequest.get() << progress;
                     }
                     // Compute the current final progress and notify it
                     double finalProgress = 0.0;
                     auto fraq = requestProgressMap.size();
                     for (auto requestProgress : requestProgressMap) {
                         finalProgress += requestProgress.second;
                         qCDebug(LOG_AmdaProvider()) << tr("Current final progress without fraq:")
                                                     << finalProgress << requestProgress.second;
                     }
                     if (fraq > 0) {
                         finalProgress = finalProgress / fraq;
                     }
                     qCDebug(LOG_AmdaProvider()) << tr("Current final progress: ") << fraq << finalProgress;
                     emit dataProvidedProgress(acqIdentifier, finalProgress);
                 }
                 else {
                     // This case can happened when a progression is send after the request has been finished.
                     // Generaly the case when aborting a request
                     emit dataProvidedProgress(acqIdentifier, 100.0);
                 }
             }
             void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)
             {
                 // Retrieves product ID from data: if the value is invalid, no request is made
                 auto productId = data.value(AMDA_XML_ID_KEY).toString();
                 if (productId.isNull()) {
                     qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
                     return;
                 }
                 // Retrieves the data type that determines whether the expected format for the result file is
                 // scalar, vector...
                 auto productValueType = valueType(data.value(AMDA_DATA_TYPE_KEY).toString());
                 // /////////// //
                 // Creates URL //
                 // /////////// //
                 auto startDate = dateFormat(dateTime.m_TStart);
                 auto endDate = dateFormat(dateTime.m_TEnd);
                 auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
                 qCInfo(LOG_AmdaProvider()) << tr("TORM AmdaProvider::retrieveData url:") << url;
                 auto tempFile = std::make_shared<QTemporaryFile>();
                 // LAMBDA
                 auto httpDownloadFinished = [this, dateTime, tempFile,
                                              productValueType](QNetworkReply *reply, QUuid dataId) noexcept {
                     // Don't do anything if the reply was abort
                     if (reply->error() == QNetworkReply::NoError) {
                         if (tempFile) {
                             auto replyReadAll = reply->readAll();
                             if (!replyReadAll.isEmpty()) {
                                 tempFile->write(replyReadAll);
                             }
                             tempFile->close();
                             // Parse results file
                             if (auto dataSeries
                                 = AmdaResultParser::readTxt(tempFile->fileName(), productValueType)) {
                                 emit dataProvided(dataId, dataSeries, dateTime);
                             }
                             else {
                                 /// @todo ALX : debug
                                 emit dataProvidedFailed(dataId);
                             }
                         }
                         qCDebug(LOG_AmdaProvider()) << tr("acquisition requests erase because of finishing")
                                                     << dataId;
                         m_AcqIdToRequestProgressMap.erase(dataId);
                     }
                     else {
                         qCCritical(LOG_AmdaProvider()) << tr("httpDownloadFinished ERROR");
                         emit dataProvidedFailed(dataId);
                     }
                 };
                 auto httpFinishedLambda
                     = [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
                           // Don't do anything if the reply was abort
                           if (reply->error() == QNetworkReply::NoError) {
-                              auto downloadFileUrl = QUrl{QString{reply->readAll()}.trimmed()};
+                              auto downloadFileUrl = QUrl{QString{reply->readAll()}};
                               qCInfo(LOG_AmdaProvider())
                                   << tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;
                               // Executes request for downloading file //
                               // Creates destination file
                               if (tempFile->open()) {
                                   // Executes request and store the request for progression
                                   auto request = std::make_shared<QNetworkRequest>(downloadFileUrl);
                                   updateRequestProgress(dataId, request, 0.0);
                                   emit requestConstructed(request, dataId, httpDownloadFinished);
                               }
                               else {
                                   emit dataProvidedFailed(dataId);
                               }
                           }
                           else {
                               qCDebug(LOG_AmdaProvider())
                                   << tr("acquisition requests erase because of aborting") << dataId;
                               qCCritical(LOG_AmdaProvider()) << tr("httpFinishedLambda ERROR");
                               m_AcqIdToRequestProgressMap.erase(dataId);
                               emit dataProvidedFailed(dataId);
                           }
                       };
                 // //////////////// //
                 // Executes request //
                 // //////////////// //
                 auto request = std::make_shared<QNetworkRequest>(url);
                 qCDebug(LOG_AmdaProvider()) << tr("First Request creation") << request.get();
                 updateRequestProgress(token, request, 0.0);
                 emit requestConstructed(request, token, httpFinishedLambda);
             }
             void AmdaProvider::updateRequestProgress(QUuid acqIdentifier,
                                                      std::shared_ptr<QNetworkRequest> request, double progress)
             {
                 auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                     auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                     auto requestProgressMapIt = requestProgressMap.find(request);
                     if (requestProgressMapIt != requestProgressMap.end()) {
                         requestProgressMapIt->second = progress;
                         qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new progress for request")
                                                     << acqIdentifier << request.get() << progress;
                     }
                     else {
                         qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new request") << acqIdentifier
                                                     << request.get() << progress;
                         acqIdToRequestProgressMapIt->second.insert(std::make_pair(request, progress));
                     }
                 }
                 else {
                     qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new acqIdentifier")
                                                 << acqIdentifier << request.get() << progress;
                     auto requestProgressMap = std::map<std::shared_ptr<QNetworkRequest>, double>{};
                     requestProgressMap.insert(std::make_pair(request, progress));
                     m_AcqIdToRequestProgressMap.insert(
                         std::make_pair(acqIdentifier, std::move(requestProgressMap)));
                 }
             }

plugins/amda/src/AmdaResultParser.cpp +20 -36

             #include "AmdaResultParser.h"
             #include <Common/DateUtils.h>
             #include <Data/ScalarSeries.h>
             #include <Data/VectorSeries.h>
             #include <QDateTime>
             #include <QFile>
             #include <QRegularExpression>
             #include <cmath>
             Q_LOGGING_CATEGORY(LOG_AmdaResultParser, "AmdaResultParser")
             namespace {
             /// Message in result file when the file was not found on server
             const auto FILE_NOT_FOUND_MESSAGE = QStringLiteral("Not Found");
-            /// Separator between values in a result line
-            const auto RESULT_LINE_SEPARATOR = QRegularExpression{QStringLiteral("\\s+")};
-            /// Regex to find the header of the data in the file. This header indicates the end of comments in
-            /// the file
-            const auto DATA_HEADER_REGEX = QRegularExpression{QStringLiteral("#\\s*DATA\\s*:")};
             /// Format for dates in result files
             const auto DATE_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss.zzz");
-            /// Regex to find unit in a line. Examples of valid lines:
+            /// Separator between values in a result line
-            /// ... PARAMETER_UNITS : nT ...
+            const auto RESULT_LINE_SEPARATOR = QRegularExpression{QStringLiteral("\\s+")};
-            /// ... PARAMETER_UNITS:nT ...
-            /// ... PARAMETER_UNITS:   m² ...
-            /// ... PARAMETER_UNITS : m/s ...
-            const auto UNIT_REGEX = QRegularExpression{QStringLiteral("\\s*PARAMETER_UNITS\\s*:\\s*(.+)")};
-            QDateTime dateTimeFromString(const QString &stringDate) noexcept
+            /// Regex to find unit in a line. Examples of valid lines:
+            /// ... - Units : nT - ...
-            #if QT_VERSION >= QT_VERSION_CHECK(5, 8, 0)
+            /// ... -Units:nT- ...
-                return QDateTime::fromString(stringDate, Qt::ISODateWithMs);
+            /// ... -Units:   m²- ...
-            #else
+            /// ... - Units : m/s - ...
-                return QDateTime::fromString(stringDate, DATE_FORMAT);
+            const auto UNIT_REGEX = QRegularExpression{QStringLiteral("-\\s*Units\\s*:\\s*(.+?)\\s*-")};
-            #endif
             /// Converts a string date to a double date
             /// @return a double that represents the date in seconds, NaN if the string date can't be converted
             double doubleDate(const QString &stringDate) noexcept
             {
-                // Format: yyyy-MM-ddThh:mm:ss.zzz
+                auto dateTime = QDateTime::fromString(stringDate, DATE_FORMAT);
-                auto dateTime = dateTimeFromString(stringDate);
                 dateTime.setTimeSpec(Qt::UTC);
                 return dateTime.isValid() ? DateUtils::secondsSinceEpoch(dateTime)
                                           : std::numeric_limits<double>::quiet_NaN();
             }
             /// Checks if a line is a comment line
             bool isCommentLine(const QString &line)
             {
                 return line.startsWith("#");
             }
             /// @return the number of lines to be read depending on the type of value passed in parameter
             int nbValues(AmdaResultParser::ValueType valueType) noexcept
             {
                 switch (valueType) {
                     case AmdaResultParser::ValueType::SCALAR:
                         return 1;
                     case AmdaResultParser::ValueType::VECTOR:
                         return 3;
                     case AmdaResultParser::ValueType::UNKNOWN:
                         // Invalid case
                         break;
                 }
                 // Invalid cases
                 qCCritical(LOG_AmdaResultParser())
                     << QObject::tr("Can't get the number of values to read: unsupported type");
                 return 0;
             }
             /**
              * Reads stream to retrieve x-axis unit
              * @param stream the stream to read
              * @return the unit that has been read in the stream, a default unit (time unit with no label) if an
              * error occured during reading
              */
             Unit readXAxisUnit(QTextStream &stream)
             {
                 QString line{};
-                // Searches unit in the comment lines (as long as the reading has not reached the data header)
+                // Searches unit in the comment lines
-                while (stream.readLineInto(&line) && !line.contains(DATA_HEADER_REGEX)) {
+                while (stream.readLineInto(&line) && isCommentLine(line)) {
                     auto match = UNIT_REGEX.match(line);
                     if (match.hasMatch()) {
                         return Unit{match.captured(1), true};
                     }
                 }
                 qCWarning(LOG_AmdaResultParser()) << QObject::tr("The unit could not be found in the file");
                 // Error cases
                 return Unit{{}, true};
             }
             /**
              * Reads stream to retrieve results
              * @param stream the stream to read
              * @return the pair of vectors x-axis data/values data that has been read in the stream
              */
             std::pair<std::vector<double>, std::vector<double> >
             readResults(QTextStream &stream, AmdaResultParser::ValueType valueType)
             {
-                auto expectedNbValues = nbValues(valueType) + 1;
+                auto expectedNbValues = nbValues(valueType);
                 auto xData = std::vector<double>{};
                 auto valuesData = std::vector<double>{};
                 QString line{};
-                // Skip comment lines
+                while (stream.readLineInto(&line)) {
-                while (stream.readLineInto(&line) && isCommentLine(line)) {
+                    // Ignore comment lines
+                    if (!isCommentLine(line)) {
-                if (!stream.atEnd()) {
-                    do {
                         auto lineData = line.split(RESULT_LINE_SEPARATOR, QString::SkipEmptyParts);
-                        if (lineData.size() == expectedNbValues) {
+                        if (lineData.size() == expectedNbValues + 1) {
                             // X : the data is converted from date to double (in secs)
                             auto x = doubleDate(lineData.at(0));
                             // Adds result only if x is valid. Then, if value is invalid, it is set to NaN
                             if (!std::isnan(x)) {
                                 xData.push_back(x);
                                 // Values
-                                for (auto valueIndex = 1; valueIndex < expectedNbValues; ++valueIndex) {
+                                for (auto valueIndex = 0; valueIndex < expectedNbValues; ++valueIndex) {
-                                    auto column = valueIndex;
+                                    auto column = valueIndex + 1;
                                     bool valueOk;
                                     auto value = lineData.at(column).toDouble(&valueOk);
                                     if (!valueOk) {
                                         qCWarning(LOG_AmdaResultParser())
                                             << QObject::tr(
                                                    "Value from (line %1, column %2) is invalid and will be "
                                                    "converted to NaN")
                                                    .arg(line, column);
                                         value = std::numeric_limits<double>::quiet_NaN();
                                     }
                                     valuesData.push_back(value);
                                 }
                             }
                             else {
                                 qCWarning(LOG_AmdaResultParser())
                                     << QObject::tr("Can't retrieve results from line %1: x is invalid")
                                            .arg(line);
                             }
                         }
                         else {
                             qCWarning(LOG_AmdaResultParser())
                                 << QObject::tr("Can't retrieve results from line %1: invalid line").arg(line);
                         }
-                    } while (stream.readLineInto(&line));
                 }
                 return std::make_pair(std::move(xData), std::move(valuesData));
             }
             } // namespace
             std::shared_ptr<IDataSeries> AmdaResultParser::readTxt(const QString &filePath,
                                                                    ValueType valueType) noexcept
             {
                 if (valueType == ValueType::UNKNOWN) {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data: the type of values to be read is unknown");
                     return nullptr;
                 }
                 QFile file{filePath};
                 if (!file.open(QFile::ReadOnly | QIODevice::Text)) {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data from file %1: %2")
                                .arg(filePath, file.errorString());
                     return nullptr;
                 }
                 QTextStream stream{&file};
                 // Checks if the file was found on the server
                 auto firstLine = stream.readLine();
                 if (firstLine.compare(FILE_NOT_FOUND_MESSAGE) == 0) {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data from file %1: file was not found on server")
                                .arg(filePath);
                     return nullptr;
                 }
                 // Reads x-axis unit
                 stream.seek(0); // returns to the beginning of the file
                 auto xAxisUnit = readXAxisUnit(stream);
                 // Reads results
+                stream.seek(0); // returns to the beginning of the file
                 auto results = readResults(stream, valueType);
                 // Creates data series
                 switch (valueType) {
                     case ValueType::SCALAR:
                         return std::make_shared<ScalarSeries>(std::move(results.first),
                                                               std::move(results.second), xAxisUnit, Unit{});
                     case ValueType::VECTOR:
                         return std::make_shared<VectorSeries>(std::move(results.first),
                                                               std::move(results.second), xAxisUnit, Unit{});
                     case ValueType::UNKNOWN:
                         // Invalid case
                         break;
                 }
                 // Invalid cases
                 qCCritical(LOG_AmdaResultParser())
                     << QObject::tr("Can't create data series: unsupported value type");
                 return nullptr;
             }

plugins/amda/tests-resources/TestAmdaResultParser/NaNValue.txt +3 -61

@@ -1,64 +1,6
1	# -----------	1	#Sampling Time : 60
2	# AMDA INFO :	2	#Time Format : YYYY-MM-DDThh:mm:ss.mls
3	# -----------	3	#imf(0) - Type : Local Parameter @ CDPP/AMDA - Name : bx_gse - Units : nT - Size : 1 - Frame : GSE - Mission : ACE - Instrument : MFI - Dataset : mfi_final-prelim
4	# AMDA_ABOUT : Created by CDPP/AMDA(c)
5	# AMDA_VERSION : 3.5.0
6	# AMDA_ACKNOWLEDGEMENT : CDPP/AMDA Team
7	#
8	# --------------
9	# REQUEST INFO :
10	# --------------
11	# REQUEST_STRUCTURE : one-file-per-parameter-per-interval
12	# REQUEST_TIME_FORMAT : ISO 8601
13	# REQUEST_OUTPUT_PARAMS : imf
14	#
15	# -----------------
16	# BASE PARAMETERS :
17	# -----------------
18	#
19	# MISSION_ID : NONE
20	#
21	# INSTRUMENT_ID : NONE
22	#
23	# DATASET_ID : ace-imf-all
24	# DATASET_NAME : final / prelim
25	# DATASET_DESCRIPTION : Interplanetary Magnetic Field 16-sec Level2/PRELIM Data
26	# DATASET_SOURCE : CDPP/DDServer
27	# DATASET_GLOBAL_START : 1997-09-02T00:00:12.000
28	# DATASET_GLOBAL_STOP : 2017-09-16T23:59:57.000
29	# DATASET_MIN_SAMPLING : 16
30	# DATASET_MAX_SAMPLING : 16
31	# DATASET_CAVEATS :
32	The quality of ACE level 2 data is such that it is suitable for serious scientific study. However, to avoid confusion and misunderstanding, it is recommended that users consult with the appropriate ACE team members before publishing work derived from the data. The ACE team has worked hard to ensure that the level 2 data are free from errors, but the team cannot accept responsibility for erroneous data, or for misunderstandings about how the data may be used. This is especially true if the appropriate ACE team members are not consulted before publication. At the very least, preprints should be forwarded to the ACE team before publication.
33
34	# DATASET_ACKNOWLEDGEMENT :
35	Please acknowledge the ACE/MAG instrument team and the ACE Science Center
36
37	#
38	# PARAMETER_ID : imf
39	# PARAMETER_NAME : imf
40	# PARAMETER_SHORT_NAME : b_gse
41	# PARAMETER_COMPONENTS : bx,by,bz
42	# PARAMETER_UNITS : nT
43	# PARAMETER_COORDINATE_SYSTEM : GSE
44	# PARAMETER_TENSOR_ORDER : 0
45	# PARAMETER_SI_CONVERSION : 1e-9>T
46	# PARAMETER_TABLE : None
47	# PARAMETER_FILL_VALUE : nan
48	# PARAMETER_UCD : phys.magField
49	#
50	#
51	# ---------------
52	# INTERVAL INFO :
53	# ---------------
54	# INTERVAL_START : 2013-09-23T08:58:12.000
55	# INTERVAL_STOP : 2013-09-23T09:11:48.000
56	#
57	# ------
58	# DATA :
59	# ------
60	# DATA_COLUMNS : AMDA_TIME, imf[0]
61	#
62	2013-09-23T09:00:30.000 NaN	4	2013-09-23T09:00:30.000 NaN
63	2013-09-23T09:01:30.000 -2.71850	5	2013-09-23T09:01:30.000 -2.71850
64	2013-09-23T09:02:30.000 -2.52150 No newline at end of file	6	2013-09-23T09:02:30.000 -2.52150

plugins/amda/tests-resources/TestAmdaResultParser/NaNX.txt +3 -61

@@ -1,64 +1,6
1	# -----------	1	#Sampling Time : 60
2	# AMDA INFO :	2	#Time Format : YYYY-MM-DDThh:mm:ss.mls
3	# -----------	3	#imf(0) - Type : Local Parameter @ CDPP/AMDA - Name : bx_gse - Units : nT - Size : 1 - Frame : GSE - Mission : ACE - Instrument : MFI - Dataset : mfi_final-prelim
4	# AMDA_ABOUT : Created by CDPP/AMDA(c)
5	# AMDA_VERSION : 3.5.0
6	# AMDA_ACKNOWLEDGEMENT : CDPP/AMDA Team
7	#
8	# --------------
9	# REQUEST INFO :
10	# --------------
11	# REQUEST_STRUCTURE : one-file-per-parameter-per-interval
12	# REQUEST_TIME_FORMAT : ISO 8601
13	# REQUEST_OUTPUT_PARAMS : imf
14	#
15	# -----------------
16	# BASE PARAMETERS :
17	# -----------------
18	#
19	# MISSION_ID : NONE
20	#
21	# INSTRUMENT_ID : NONE
22	#
23	# DATASET_ID : ace-imf-all
24	# DATASET_NAME : final / prelim
25	# DATASET_DESCRIPTION : Interplanetary Magnetic Field 16-sec Level2/PRELIM Data
26	# DATASET_SOURCE : CDPP/DDServer
27	# DATASET_GLOBAL_START : 1997-09-02T00:00:12.000
28	# DATASET_GLOBAL_STOP : 2017-09-16T23:59:57.000
29	# DATASET_MIN_SAMPLING : 16
30	# DATASET_MAX_SAMPLING : 16
31	# DATASET_CAVEATS :
32	The quality of ACE level 2 data is such that it is suitable for serious scientific study. However, to avoid confusion and misunderstanding, it is recommended that users consult with the appropriate ACE team members before publishing work derived from the data. The ACE team has worked hard to ensure that the level 2 data are free from errors, but the team cannot accept responsibility for erroneous data, or for misunderstandings about how the data may be used. This is especially true if the appropriate ACE team members are not consulted before publication. At the very least, preprints should be forwarded to the ACE team before publication.
33
34	# DATASET_ACKNOWLEDGEMENT :
35	Please acknowledge the ACE/MAG instrument team and the ACE Science Center
36
37	#
38	# PARAMETER_ID : imf
39	# PARAMETER_NAME : imf
40	# PARAMETER_SHORT_NAME : b_gse
41	# PARAMETER_COMPONENTS : bx,by,bz
42	# PARAMETER_UNITS : nT
43	# PARAMETER_COORDINATE_SYSTEM : GSE
44	# PARAMETER_TENSOR_ORDER : 0
45	# PARAMETER_SI_CONVERSION : 1e-9>T
46	# PARAMETER_TABLE : None
47	# PARAMETER_FILL_VALUE : nan
48	# PARAMETER_UCD : phys.magField
49	#
50	#
51	# ---------------
52	# INTERVAL INFO :
53	# ---------------
54	# INTERVAL_START : 2013-09-23T08:58:12.000
55	# INTERVAL_STOP : 2013-09-23T09:11:48.000
56	#
57	# ------
58	# DATA :
59	# ------
60	# DATA_COLUMNS : AMDA_TIME, imf[0]
61	#
62	NaN -3.01425	4	NaN -3.01425
63	2013-09-23T09:01:30.000 -2.71850	5	2013-09-23T09:01:30.000 -2.71850
64	2013-09-23T09:02:30.000 -2.52150 No newline at end of file	6	2013-09-23T09:02:30.000 -2.52150

plugins/amda/tests-resources/TestAmdaResultParser/NoUnit.txt +2 -60

@@ -1,60 +1,2
1	# -----------	1	#Sampling Time : 60
2	# AMDA INFO :	2	#Time Format : YYYY-MM-DDThh:mm:ss.mls No newline at end of file
3	# -----------
4	# AMDA_ABOUT : Created by CDPP/AMDA(c)
5	# AMDA_VERSION : 3.5.0
6	# AMDA_ACKNOWLEDGEMENT : CDPP/AMDA Team
7	#
8	# --------------
9	# REQUEST INFO :
10	# --------------
11	# REQUEST_STRUCTURE : one-file-per-parameter-per-interval
12	# REQUEST_TIME_FORMAT : ISO 8601
13	# REQUEST_OUTPUT_PARAMS : imf
14	#
15	# -----------------
16	# BASE PARAMETERS :
17	# -----------------
18	#
19	# MISSION_ID : NONE
20	#
21	# INSTRUMENT_ID : NONE
22	#
23	# DATASET_ID : ace-imf-all
24	# DATASET_NAME : final / prelim
25	# DATASET_DESCRIPTION : Interplanetary Magnetic Field 16-sec Level2/PRELIM Data
26	# DATASET_SOURCE : CDPP/DDServer
27	# DATASET_GLOBAL_START : 1997-09-02T00:00:12.000
28	# DATASET_GLOBAL_STOP : 2017-09-16T23:59:57.000
29	# DATASET_MIN_SAMPLING : 16
30	# DATASET_MAX_SAMPLING : 16
31	# DATASET_CAVEATS :
32	The quality of ACE level 2 data is such that it is suitable for serious scientific study. However, to avoid confusion and misunderstanding, it is recommended that users consult with the appropriate ACE team members before publishing work derived from the data. The ACE team has worked hard to ensure that the level 2 data are free from errors, but the team cannot accept responsibility for erroneous data, or for misunderstandings about how the data may be used. This is especially true if the appropriate ACE team members are not consulted before publication. At the very least, preprints should be forwarded to the ACE team before publication.
33
34	# DATASET_ACKNOWLEDGEMENT :
35	Please acknowledge the ACE/MAG instrument team and the ACE Science Center
36
37	#
38	# PARAMETER_ID : imf
39	# PARAMETER_NAME : imf
40	# PARAMETER_SHORT_NAME : b_gse
41	# PARAMETER_COMPONENTS : bx,by,bz
42	# PARAMETER_COORDINATE_SYSTEM : GSE
43	# PARAMETER_TENSOR_ORDER : 0
44	# PARAMETER_SI_CONVERSION : 1e-9>T
45	# PARAMETER_TABLE : None
46	# PARAMETER_FILL_VALUE : nan
47	# PARAMETER_UCD : phys.magField
48	#
49	#
50	# ---------------
51	# INTERVAL INFO :
52	# ---------------
53	# INTERVAL_START : 2013-09-23T08:58:12.000
54	# INTERVAL_STOP : 2013-09-23T09:11:48.000
55	#
56	# ------
57	# DATA :
58	# ------
59	# DATA_COLUMNS : AMDA_TIME, imf[0]
60	# No newline at end of file

plugins/amda/tests-resources/TestAmdaResultParser/TooManyValues.txt +3 -61

@@ -1,64 +1,6
1	# -----------	1	#Sampling Time : 60
2	# AMDA INFO :	2	#Time Format : YYYY-MM-DDThh:mm:ss.mls
3	# -----------	3	#imf(0) - Type : Local Parameter @ CDPP/AMDA - Name : bx_gse - Units : nT - Size : 1 - Frame : GSE - Mission : ACE - Instrument : MFI - Dataset : mfi_final-prelim
4	# AMDA_ABOUT : Created by CDPP/AMDA(c)
5	# AMDA_VERSION : 3.5.0
6	# AMDA_ACKNOWLEDGEMENT : CDPP/AMDA Team
7	#
8	# --------------
9	# REQUEST INFO :
10	# --------------
11	# REQUEST_STRUCTURE : one-file-per-parameter-per-interval
12	# REQUEST_TIME_FORMAT : ISO 8601
13	# REQUEST_OUTPUT_PARAMS : imf
14	#
15	# -----------------
16	# BASE PARAMETERS :
17	# -----------------
18	#
19	# MISSION_ID : NONE
20	#
21	# INSTRUMENT_ID : NONE
22	#
23	# DATASET_ID : ace-imf-all
24	# DATASET_NAME : final / prelim
25	# DATASET_DESCRIPTION : Interplanetary Magnetic Field 16-sec Level2/PRELIM Data
26	# DATASET_SOURCE : CDPP/DDServer
27	# DATASET_GLOBAL_START : 1997-09-02T00:00:12.000
28	# DATASET_GLOBAL_STOP : 2017-09-16T23:59:57.000
29	# DATASET_MIN_SAMPLING : 16
30	# DATASET_MAX_SAMPLING : 16
31	# DATASET_CAVEATS :
32	The quality of ACE level 2 data is such that it is suitable for serious scientific study. However, to avoid confusion and misunderstanding, it is recommended that users consult with the appropriate ACE team members before publishing work derived from the data. The ACE team has worked hard to ensure that the level 2 data are free from errors, but the team cannot accept responsibility for erroneous data, or for misunderstandings about how the data may be used. This is especially true if the appropriate ACE team members are not consulted before publication. At the very least, preprints should be forwarded to the ACE team before publication.
33
34	# DATASET_ACKNOWLEDGEMENT :
35	Please acknowledge the ACE/MAG instrument team and the ACE Science Center
36
37	#
38	# PARAMETER_ID : imf
39	# PARAMETER_NAME : imf
40	# PARAMETER_SHORT_NAME : b_gse
41	# PARAMETER_COMPONENTS : bx,by,bz
42	# PARAMETER_UNITS : nT
43	# PARAMETER_COORDINATE_SYSTEM : GSE
44	# PARAMETER_TENSOR_ORDER : 0
45	# PARAMETER_SI_CONVERSION : 1e-9>T
46	# PARAMETER_TABLE : None
47	# PARAMETER_FILL_VALUE : nan
48	# PARAMETER_UCD : phys.magField
49	#
50	#
51	# ---------------
52	# INTERVAL INFO :
53	# ---------------
54	# INTERVAL_START : 2013-09-23T08:58:12.000
55	# INTERVAL_STOP : 2013-09-23T09:11:48.000
56	#
57	# ------
58	# DATA :
59	# ------
60	# DATA_COLUMNS : AMDA_TIME, imf[0]
61	#
62	2013-09-23T09:00:30.000 -2.83950 1.05141 3.01547	4	2013-09-23T09:00:30.000 -2.83950 1.05141 3.01547
63	2013-09-23T09:01:30.000 -2.71850	5	2013-09-23T09:01:30.000 -2.71850
64	2013-09-23T09:02:30.000 -2.52150 No newline at end of file	6	2013-09-23T09:02:30.000 -2.52150

plugins/amda/tests-resources/TestAmdaResultParser/ValidScalar1.txt +3 -61

@@ -1,71 +1,13
1	# -----------	1	#Sampling Time : 60
2	# AMDA INFO :	2	#Time Format : YYYY-MM-DDThh:mm:ss.mls
3	# -----------	3	#imf(0) - Type : Local Parameter @ CDPP/AMDA - Name : bx_gse - Units : nT - Size : 1 - Frame : GSE - Mission : ACE - Instrument : MFI - Dataset : mfi_final-prelim
4	# AMDA_ABOUT : Created by CDPP/AMDA(c)
5	# AMDA_VERSION : 3.5.0
6	# AMDA_ACKNOWLEDGEMENT : CDPP/AMDA Team
7	#
8	# --------------
9	# REQUEST INFO :
10	# --------------
11	# REQUEST_STRUCTURE : one-file-per-parameter-per-interval
12	# REQUEST_TIME_FORMAT : ISO 8601
13	# REQUEST_OUTPUT_PARAMS : imf
14	#
15	# -----------------
16	# BASE PARAMETERS :
17	# -----------------
18	#
19	# MISSION_ID : NONE
20	#
21	# INSTRUMENT_ID : NONE
22	#
23	# DATASET_ID : ace-imf-all
24	# DATASET_NAME : final / prelim
25	# DATASET_DESCRIPTION : Interplanetary Magnetic Field 16-sec Level2/PRELIM Data
26	# DATASET_SOURCE : CDPP/DDServer
27	# DATASET_GLOBAL_START : 1997-09-02T00:00:12.000
28	# DATASET_GLOBAL_STOP : 2017-09-16T23:59:57.000
29	# DATASET_MIN_SAMPLING : 16
30	# DATASET_MAX_SAMPLING : 16
31	# DATASET_CAVEATS :
32	The quality of ACE level 2 data is such that it is suitable for serious scientific study. However, to avoid confusion and misunderstanding, it is recommended that users consult with the appropriate ACE team members before publishing work derived from the data. The ACE team has worked hard to ensure that the level 2 data are free from errors, but the team cannot accept responsibility for erroneous data, or for misunderstandings about how the data may be used. This is especially true if the appropriate ACE team members are not consulted before publication. At the very least, preprints should be forwarded to the ACE team before publication.
33
34	# DATASET_ACKNOWLEDGEMENT :
35	Please acknowledge the ACE/MAG instrument team and the ACE Science Center
36
37	#
38	# PARAMETER_ID : imf
39	# PARAMETER_NAME : imf
40	# PARAMETER_SHORT_NAME : b_gse
41	# PARAMETER_COMPONENTS : bx,by,bz
42	# PARAMETER_UNITS : nT
43	# PARAMETER_COORDINATE_SYSTEM : GSE
44	# PARAMETER_TENSOR_ORDER : 0
45	# PARAMETER_SI_CONVERSION : 1e-9>T
46	# PARAMETER_TABLE : None
47	# PARAMETER_FILL_VALUE : nan
48	# PARAMETER_UCD : phys.magField
49	#
50	#
51	# ---------------
52	# INTERVAL INFO :
53	# ---------------
54	# INTERVAL_START : 2013-09-23T08:58:12.000
55	# INTERVAL_STOP : 2013-09-23T09:11:48.000
56	#
57	# ------
58	# DATA :
59	# ------
60	# DATA_COLUMNS : AMDA_TIME, imf[0]
61	#
62	2013-09-23T09:00:30.000 -2.83950	4	2013-09-23T09:00:30.000 -2.83950
63	2013-09-23T09:01:30.000 -2.71850	5	2013-09-23T09:01:30.000 -2.71850
64	2013-09-23T09:02:30.000 -2.52150	6	2013-09-23T09:02:30.000 -2.52150
65	2013-09-23T09:03:30.000 -2.57633	7	2013-09-23T09:03:30.000 -2.57633
66	2013-09-23T09:04:30.000 -2.58050	8	2013-09-23T09:04:30.000 -2.58050
67	2013-09-23T09:05:30.000 -2.48325	9	2013-09-23T09:05:30.000 -2.48325
68	2013-09-23T09:06:30.000 -2.63025	10	2013-09-23T09:06:30.000 -2.63025
69	2013-09-23T09:07:30.000 -2.55800	11	2013-09-23T09:07:30.000 -2.55800
70	2013-09-23T09:08:30.000 -2.43250	12	2013-09-23T09:08:30.000 -2.43250
71	2013-09-23T09:09:30.000 -2.42200 No newline at end of file	13	2013-09-23T09:09:30.000 -2.42200

plugins/amda/tests-resources/TestAmdaResultParser/ValidVector1.txt +2 -61

@@ -1,71 +1,12
1	# -----------	1	#Time Format : YYYY-MM-DDThh:mm:ss.mls
2	# AMDA INFO :	2	#imf - Type : Local Parameter @ CDPP/AMDA - Name : imf_gse - Units : nT - Size : 3 - Frame : GSE - Mission : ACE - Instrument : MFI - Dataset : mfi_final-prelim
3	# -----------
4	# AMDA_ABOUT : Created by CDPP/AMDA(c)
5	# AMDA_VERSION : 3.5.0
6	# AMDA_ACKNOWLEDGEMENT : CDPP/AMDA Team
7	#
8	# --------------
9	# REQUEST INFO :
10	# --------------
11	# REQUEST_STRUCTURE : one-file-per-parameter-per-interval
12	# REQUEST_TIME_FORMAT : ISO 8601
13	# REQUEST_OUTPUT_PARAMS : imf
14	#
15	# -----------------
16	# BASE PARAMETERS :
17	# -----------------
18	#
19	# MISSION_ID : NONE
20	#
21	# INSTRUMENT_ID : NONE
22	#
23	# DATASET_ID : ace-imf-all
24	# DATASET_NAME : final / prelim
25	# DATASET_DESCRIPTION : Interplanetary Magnetic Field 16-sec Level2/PRELIM Data
26	# DATASET_SOURCE : CDPP/DDServer
27	# DATASET_GLOBAL_START : 1997-09-02T00:00:12.000
28	# DATASET_GLOBAL_STOP : 2017-09-16T23:59:57.000
29	# DATASET_MIN_SAMPLING : 16
30	# DATASET_MAX_SAMPLING : 16
31	# DATASET_CAVEATS :
32	The quality of ACE level 2 data is such that it is suitable for serious scientific study. However, to avoid confusion and misunderstanding, it is recommended that users consult with the appropriate ACE team members before publishing work derived from the data. The ACE team has worked hard to ensure that the level 2 data are free from errors, but the team cannot accept responsibility for erroneous data, or for misunderstandings about how the data may be used. This is especially true if the appropriate ACE team members are not consulted before publication. At the very least, preprints should be forwarded to the ACE team before publication.
33
34	# DATASET_ACKNOWLEDGEMENT :
35	Please acknowledge the ACE/MAG instrument team and the ACE Science Center
36
37	#
38	# PARAMETER_ID : imf
39	# PARAMETER_NAME : imf
40	# PARAMETER_SHORT_NAME : b_gse
41	# PARAMETER_COMPONENTS : bx,by,bz
42	# PARAMETER_UNITS : nT
43	# PARAMETER_COORDINATE_SYSTEM : GSE
44	# PARAMETER_TENSOR_ORDER : 0
45	# PARAMETER_SI_CONVERSION : 1e-9>T
46	# PARAMETER_TABLE : None
47	# PARAMETER_FILL_VALUE : nan
48	# PARAMETER_UCD : phys.magField
49	#
50	#
51	# ---------------
52	# INTERVAL INFO :
53	# ---------------
54	# INTERVAL_START : 2012-09-27T06:47:56.000
55	# INTERVAL_STOP : 2012-09-27T08:09:32.000
56	#
57	# ------
58	# DATA :
59	# ------
60	# DATA_COLUMNS : AMDA_TIME, imf[0], imf[1], imf[2]
61	#
62	2013-07-02T09:13:50.000 -0.332000 3.20600 0.0580000	3	2013-07-02T09:13:50.000 -0.332000 3.20600 0.0580000
63	2013-07-02T09:14:06.000 -1.01100 2.99900 0.496000	4	2013-07-02T09:14:06.000 -1.01100 2.99900 0.496000
64	2013-07-02T09:14:22.000 -1.45700 2.78500 1.01800	5	2013-07-02T09:14:22.000 -1.45700 2.78500 1.01800
65	2013-07-02T09:14:38.000 -1.29300 2.73600 1.48500	6	2013-07-02T09:14:38.000 -1.29300 2.73600 1.48500
66	2013-07-02T09:14:54.000 -1.21700 2.61200 1.66200	7	2013-07-02T09:14:54.000 -1.21700 2.61200 1.66200
67	2013-07-02T09:15:10.000 -1.44300 2.56400 1.50500	8	2013-07-02T09:15:10.000 -1.44300 2.56400 1.50500
68	2013-07-02T09:15:26.000 -1.27800 2.89200 1.16800	9	2013-07-02T09:15:26.000 -1.27800 2.89200 1.16800
69	2013-07-02T09:15:42.000 -1.20200 2.86200 1.24400	10	2013-07-02T09:15:42.000 -1.20200 2.86200 1.24400
70	2013-07-02T09:15:58.000 -1.22000 2.85900 1.15000	11	2013-07-02T09:15:58.000 -1.22000 2.85900 1.15000
71	2013-07-02T09:16:14.000 -1.25900 2.76400 1.35800 No newline at end of file	12	2013-07-02T09:16:14.000 -1.25900 2.76400 1.35800

plugins/amda/tests-resources/TestAmdaResultParser/WrongDate.txt +3 -61

@@ -1,64 +1,6
1	# -----------	1	#Sampling Time : 60
2	# AMDA INFO :	2	#Time Format : YYYY-MM-DDThh:mm:ss.mls
3	# -----------	3	#imf(0) - Type : Local Parameter @ CDPP/AMDA - Name : bx_gse - Units : nT - Size : 1 - Frame : GSE - Mission : ACE - Instrument : MFI - Dataset : mfi_final-prelim
4	# AMDA_ABOUT : Created by CDPP/AMDA(c)
5	# AMDA_VERSION : 3.5.0
6	# AMDA_ACKNOWLEDGEMENT : CDPP/AMDA Team
7	#
8	# --------------
9	# REQUEST INFO :
10	# --------------
11	# REQUEST_STRUCTURE : one-file-per-parameter-per-interval
12	# REQUEST_TIME_FORMAT : ISO 8601
13	# REQUEST_OUTPUT_PARAMS : imf
14	#
15	# -----------------
16	# BASE PARAMETERS :
17	# -----------------
18	#
19	# MISSION_ID : NONE
20	#
21	# INSTRUMENT_ID : NONE
22	#
23	# DATASET_ID : ace-imf-all
24	# DATASET_NAME : final / prelim
25	# DATASET_DESCRIPTION : Interplanetary Magnetic Field 16-sec Level2/PRELIM Data
26	# DATASET_SOURCE : CDPP/DDServer
27	# DATASET_GLOBAL_START : 1997-09-02T00:00:12.000
28	# DATASET_GLOBAL_STOP : 2017-09-16T23:59:57.000
29	# DATASET_MIN_SAMPLING : 16
30	# DATASET_MAX_SAMPLING : 16
31	# DATASET_CAVEATS :
32	The quality of ACE level 2 data is such that it is suitable for serious scientific study. However, to avoid confusion and misunderstanding, it is recommended that users consult with the appropriate ACE team members before publishing work derived from the data. The ACE team has worked hard to ensure that the level 2 data are free from errors, but the team cannot accept responsibility for erroneous data, or for misunderstandings about how the data may be used. This is especially true if the appropriate ACE team members are not consulted before publication. At the very least, preprints should be forwarded to the ACE team before publication.
33
34	# DATASET_ACKNOWLEDGEMENT :
35	Please acknowledge the ACE/MAG instrument team and the ACE Science Center
36
37	#
38	# PARAMETER_ID : imf
39	# PARAMETER_NAME : imf
40	# PARAMETER_SHORT_NAME : b_gse
41	# PARAMETER_COMPONENTS : bx,by,bz
42	# PARAMETER_UNITS : nT
43	# PARAMETER_COORDINATE_SYSTEM : GSE
44	# PARAMETER_TENSOR_ORDER : 0
45	# PARAMETER_SI_CONVERSION : 1e-9>T
46	# PARAMETER_TABLE : None
47	# PARAMETER_FILL_VALUE : nan
48	# PARAMETER_UCD : phys.magField
49	#
50	#
51	# ---------------
52	# INTERVAL INFO :
53	# ---------------
54	# INTERVAL_START : 2013-09-23T08:58:12.000
55	# INTERVAL_STOP : 2013-09-23T09:11:48.000
56	#
57	# ------
58	# DATA :
59	# ------
60	# DATA_COLUMNS : AMDA_TIME, imf[0]
61	#
62	23/09/2013 07:50:30 -2.83950	4	23/09/2013 07:50:30 -2.83950
63	2013-09-23T09:01:30.000 -2.71850	5	2013-09-23T09:01:30.000 -2.71850
64	2013-09-23T09:02:30.000 -2.52150 No newline at end of file	6	2013-09-23T09:02:30.000 -2.52150

plugins/amda/tests-resources/TestAmdaResultParser/WrongUnit.txt +3 -61

@@ -1,64 +1,6
1	# -----------	1	#Sampling Time : 60
2	# AMDA INFO :	2	#Time Format : YYYY-MM-DDThh:mm:ss.mls
3	# -----------	3	#Wrong unit comment
4	# AMDA_ABOUT : Created by CDPP/AMDA(c)
5	# AMDA_VERSION : 3.5.0
6	# AMDA_ACKNOWLEDGEMENT : CDPP/AMDA Team
7	#
8	# --------------
9	# REQUEST INFO :
10	# --------------
11	# REQUEST_STRUCTURE : one-file-per-parameter-per-interval
12	# REQUEST_TIME_FORMAT : ISO 8601
13	# REQUEST_OUTPUT_PARAMS : imf
14	#
15	# -----------------
16	# BASE PARAMETERS :
17	# -----------------
18	#
19	# MISSION_ID : NONE
20	#
21	# INSTRUMENT_ID : NONE
22	#
23	# DATASET_ID : ace-imf-all
24	# DATASET_NAME : final / prelim
25	# DATASET_DESCRIPTION : Interplanetary Magnetic Field 16-sec Level2/PRELIM Data
26	# DATASET_SOURCE : CDPP/DDServer
27	# DATASET_GLOBAL_START : 1997-09-02T00:00:12.000
28	# DATASET_GLOBAL_STOP : 2017-09-16T23:59:57.000
29	# DATASET_MIN_SAMPLING : 16
30	# DATASET_MAX_SAMPLING : 16
31	# DATASET_CAVEATS :
32	The quality of ACE level 2 data is such that it is suitable for serious scientific study. However, to avoid confusion and misunderstanding, it is recommended that users consult with the appropriate ACE team members before publishing work derived from the data. The ACE team has worked hard to ensure that the level 2 data are free from errors, but the team cannot accept responsibility for erroneous data, or for misunderstandings about how the data may be used. This is especially true if the appropriate ACE team members are not consulted before publication. At the very least, preprints should be forwarded to the ACE team before publication.
33
34	# DATASET_ACKNOWLEDGEMENT :
35	Please acknowledge the ACE/MAG instrument team and the ACE Science Center
36
37	#
38	# PARAMETER_ID : imf
39	# PARAMETER_NAME : imf
40	# PARAMETER_SHORT_NAME : b_gse
41	# PARAMETER_COMPONENTS : bx,by,bz
42	# PARAM_UNITS : wrong unit line
43	# PARAMETER_COORDINATE_SYSTEM : GSE
44	# PARAMETER_TENSOR_ORDER : 0
45	# PARAMETER_SI_CONVERSION : 1e-9>T
46	# PARAMETER_TABLE : None
47	# PARAMETER_FILL_VALUE : nan
48	# PARAMETER_UCD : phys.magField
49	#
50	#
51	# ---------------
52	# INTERVAL INFO :
53	# ---------------
54	# INTERVAL_START : 2013-09-23T08:58:12.000
55	# INTERVAL_STOP : 2013-09-23T09:11:48.000
56	#
57	# ------
58	# DATA :
59	# ------
60	# DATA_COLUMNS : AMDA_TIME, imf[0]
61	#
62	2013-09-23T09:00:30.000 -2.83950	4	2013-09-23T09:00:30.000 -2.83950
63	2013-09-23T09:01:30.000 -2.71850	5	2013-09-23T09:01:30.000 -2.71850
64	2013-09-23T09:02:30.000 -2.52150 No newline at end of file	6	2013-09-23T09:02:30.000 -2.52150

plugins/amda/tests-resources/TestAmdaResultParser/WrongValue.txt +3 -61

@@ -1,64 +1,6
1	# -----------	1	#Sampling Time : 60
2	# AMDA INFO :	2	#Time Format : YYYY-MM-DDThh:mm:ss.mls
3	# -----------	3	#imf(0) - Type : Local Parameter @ CDPP/AMDA - Name : bx_gse - Units : nT - Size : 1 - Frame : GSE - Mission : ACE - Instrument : MFI - Dataset : mfi_final-prelim
4	# AMDA_ABOUT : Created by CDPP/AMDA(c)
5	# AMDA_VERSION : 3.5.0
6	# AMDA_ACKNOWLEDGEMENT : CDPP/AMDA Team
7	#
8	# --------------
9	# REQUEST INFO :
10	# --------------
11	# REQUEST_STRUCTURE : one-file-per-parameter-per-interval
12	# REQUEST_TIME_FORMAT : ISO 8601
13	# REQUEST_OUTPUT_PARAMS : imf
14	#
15	# -----------------
16	# BASE PARAMETERS :
17	# -----------------
18	#
19	# MISSION_ID : NONE
20	#
21	# INSTRUMENT_ID : NONE
22	#
23	# DATASET_ID : ace-imf-all
24	# DATASET_NAME : final / prelim
25	# DATASET_DESCRIPTION : Interplanetary Magnetic Field 16-sec Level2/PRELIM Data
26	# DATASET_SOURCE : CDPP/DDServer
27	# DATASET_GLOBAL_START : 1997-09-02T00:00:12.000
28	# DATASET_GLOBAL_STOP : 2017-09-16T23:59:57.000
29	# DATASET_MIN_SAMPLING : 16
30	# DATASET_MAX_SAMPLING : 16
31	# DATASET_CAVEATS :
32	The quality of ACE level 2 data is such that it is suitable for serious scientific study. However, to avoid confusion and misunderstanding, it is recommended that users consult with the appropriate ACE team members before publishing work derived from the data. The ACE team has worked hard to ensure that the level 2 data are free from errors, but the team cannot accept responsibility for erroneous data, or for misunderstandings about how the data may be used. This is especially true if the appropriate ACE team members are not consulted before publication. At the very least, preprints should be forwarded to the ACE team before publication.
33
34	# DATASET_ACKNOWLEDGEMENT :
35	Please acknowledge the ACE/MAG instrument team and the ACE Science Center
36
37	#
38	# PARAMETER_ID : imf
39	# PARAMETER_NAME : imf
40	# PARAMETER_SHORT_NAME : b_gse
41	# PARAMETER_COMPONENTS : bx,by,bz
42	# PARAMETER_UNITS : nT
43	# PARAMETER_COORDINATE_SYSTEM : GSE
44	# PARAMETER_TENSOR_ORDER : 0
45	# PARAMETER_SI_CONVERSION : 1e-9>T
46	# PARAMETER_TABLE : None
47	# PARAMETER_FILL_VALUE : nan
48	# PARAMETER_UCD : phys.magField
49	#
50	#
51	# ---------------
52	# INTERVAL INFO :
53	# ---------------
54	# INTERVAL_START : 2013-09-23T08:58:12.000
55	# INTERVAL_STOP : 2013-09-23T09:11:48.000
56	#
57	# ------
58	# DATA :
59	# ------
60	# DATA_COLUMNS : AMDA_TIME, imf[0]
61	#
62	2013-09-23T09:00:30.000 abc	4	2013-09-23T09:00:30.000 abc
63	2013-09-23T09:01:30.000 -2.71850	5	2013-09-23T09:01:30.000 -2.71850
64	2013-09-23T09:02:30.000 -2.52150 No newline at end of file	6	2013-09-23T09:02:30.000 -2.52150

plugins/amda/tests/TestAmdaAcquisition.cpp +2 -4

             #include "AmdaProvider.h"
             #include "AmdaResultParser.h"
             #include "SqpApplication.h"
             #include <Data/DataSeries.h>
             #include <Data/IDataSeries.h>
             #include <Data/ScalarSeries.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QObject>
             #include <QtTest>
             #include <memory>
             // TEST with REF:
             // AmdaData-2012-01-01-12-00-00_2012-01-03-12-00-00
             // imf(0) - Type : Local Parameter @ CDPP/AMDA -
             // Name : bx_gse - Units : nT - Size : 1 -
             // Frame : GSE - Mission : ACE -
             // Instrument : MFI - Dataset : mfi_final-prelim
             // REFERENCE DOWNLOAD FILE =
             // http://amda.irap.omp.eu/php/rest/getParameter.php?startTime=2012-01-01T12:00:00&stopTime=2012-01-03T12:00:00&parameterID=imf(0)&outputFormat=ASCII&timeFormat=ISO8601&gzip=0
             namespace {
             /// Path for the tests
             const auto TESTS_RESOURCES_PATH
                 = QFileInfo{QString{AMDA_TESTS_RESOURCES_DIR}, "TestAmdaAcquisition"}.absoluteFilePath();
             const auto TESTS_AMDA_REF_FILE = QString{"AmdaData-2012-01-01-12-00-00_2012-01-03-12-00-00.txt"};
             template <typename T>
             bool compareDataSeries(std::shared_ptr<IDataSeries> candidate, SqpRange candidateCacheRange,
                                    std::shared_ptr<IDataSeries> reference)
             {
                 auto compareLambda = [](const auto &it1, const auto &it2) {
                     return (it1.x() == it2.x()) && (it1.value() == it2.value());
                 };
                 auto candidateDS = std::dynamic_pointer_cast<T>(candidate);
                 auto referenceDS = std::dynamic_pointer_cast<T>(reference);
                 if (candidateDS && referenceDS) {
                     auto itRefs
                         = referenceDS->xAxisRange(candidateCacheRange.m_TStart, candidateCacheRange.m_TEnd);
                     qDebug() << " DISTANCE" << std::distance(candidateDS->cbegin(), candidateDS->cend())
                              << std::distance(itRefs.first, itRefs.second);
                     //        auto xcValue = candidateDS->valuesData()->data();
                     //        auto dist = std::distance(itRefs.first, itRefs.second);
                     //        auto it = itRefs.first;
                     //        for (auto i = 0; i < dist - 1; ++i) {
                     //            ++it;
                     //            qInfo() << "END:" << it->value();
                     //        }
                     //        qDebug() << "END:" << it->value() << xcValue.last();
                     return std::equal(candidateDS->cbegin(), candidateDS->cend(), itRefs.first, itRefs.second,
                                       compareLambda);
                 }
                 else {
                     return false;
                 }
             }
             }
             class TestAmdaAcquisition : public QObject {
                 Q_OBJECT
             private slots:
                 void testAcquisition();
             };
             void TestAmdaAcquisition::testAcquisition()
             {
-                /// @todo: update test to be compatible with AMDA v2
                 // READ the ref file:
                 auto filePath = QFileInfo{TESTS_RESOURCES_PATH, TESTS_AMDA_REF_FILE}.absoluteFilePath();
                 auto results = AmdaResultParser::readTxt(filePath, AmdaResultParser::ValueType::SCALAR);
                 auto provider = std::make_shared<AmdaProvider>();
                 auto timeController = std::make_unique<TimeController>();
                 auto varRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 3, 0, 0}};
                 auto varRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 4, 0, 0}};
                 auto sqpR = SqpRange{DateUtils::secondsSinceEpoch(varRS), DateUtils::secondsSinceEpoch(varRE)};
                 timeController->onTimeToUpdate(sqpR);
                 QVariantHash metaData;
                 metaData.insert("dataType", "scalar");
                 metaData.insert("xml:id", "imf(0)");
                 VariableController vc;
                 vc.setTimeController(timeController.get());
                 auto var = vc.createVariable("bx_gse", metaData, provider);
                 // 1 : Variable creation
                 qDebug() << " 1: TIMECONTROLLER" << timeController->dateTime();
                 qDebug() << " 1: RANGE     " << var->range();
                 qDebug() << " 1: CACHERANGE" << var->cacheRange();
                 // wait for 10 sec before asking next request toi permit asynchrone process to finish.
                 auto timeToWaitMs = 10000;
                 QEventLoop loop;
                 QTimer::singleShot(timeToWaitMs, &loop, &QEventLoop::quit);
                 loop.exec();
                 // Tests on acquisition operation
                 int count = 1;
                 auto requestDataLoading = [&vc, var, timeToWaitMs, results, &count](auto tStart, auto tEnd) {
                     ++count;
                     auto nextSqpR
                         = SqpRange{DateUtils::secondsSinceEpoch(tStart), DateUtils::secondsSinceEpoch(tEnd)};
                     vc.onRequestDataLoading(QVector<std::shared_ptr<Variable> >{} << var, nextSqpR,
                                             var->range(), true);
                     QEventLoop loop;
                     QTimer::singleShot(timeToWaitMs, &loop, &QEventLoop::quit);
                     loop.exec();
                     qInfo() << count << "RANGE     " << var->range();
                     qInfo() << count << "CACHERANGE" << var->cacheRange();
                     QCOMPARE(var->range().m_TStart, nextSqpR.m_TStart);
                     QCOMPARE(var->range().m_TEnd, nextSqpR.m_TEnd);
                     // Verify dataserie
                     QVERIFY(compareDataSeries<ScalarSeries>(var->dataSeries(), var->cacheRange(), results));
                 };
                 // 2 : pan (jump) left for one hour
                 auto nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 1, 0, 0}};
                 auto nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 2, 0, 0}};
-                // requestDataLoading(nextVarRS, nextVarRE);
+                requestDataLoading(nextVarRS, nextVarRE);
                 // 3 : pan (jump) right for one hour
                 nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 5, 0, 0}};
                 nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 6, 0, 0}};
-                // requestDataLoading(nextVarRS, nextVarRE);
+                requestDataLoading(nextVarRS, nextVarRE);
                 // 4 : pan (overlay) right for 30 min
                 nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 5, 30, 0}};
                 nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 6, 30, 0}};
                 // requestDataLoading(nextVarRS, nextVarRE);
                 // 5 : pan (overlay) left for 30 min
                 nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 5, 0, 0}};
                 nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 6, 0, 0}};
                 // requestDataLoading(nextVarRS, nextVarRE);
                 // 6 : pan (overlay) left for 30 min - BIS
                 nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 4, 30, 0}};
                 nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 5, 30, 0}};
                 // requestDataLoading(nextVarRS, nextVarRE);
                 // 7 : Zoom in Inside 20 min range
                 nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 4, 50, 0}};
                 nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 5, 10, 0}};
                 // requestDataLoading(nextVarRS, nextVarRE);
                 // 8 : Zoom out Inside 2 hours range
                 nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 4, 0, 0}};
                 nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 6, 0, 0}};
                 // requestDataLoading(nextVarRS, nextVarRE);
                 // Close the app after 10 sec
                 QTimer::singleShot(timeToWaitMs, &loop, &QEventLoop::quit);
                 loop.exec();
             }
             int main(int argc, char *argv[])
             {
                 SqpApplication app(argc, argv);
                 app.setAttribute(Qt::AA_Use96Dpi, true);
                 TestAmdaAcquisition tc;
                 QTEST_SET_MAIN_SOURCE_PATH
                 return QTest::qExec(&tc, argc, argv);
             }
             // QTEST_MAIN(TestAmdaAcquisition)
             #include "TestAmdaAcquisition.moc"

core/include/Variable/VariableCacheStrategyFactory.h removed 0 -44

NO CONTENT: file was removed

core/include/Variable/VariableSingleThresholdCacheStrategy.h removed 0 -32

NO CONTENT: file was removed

core/tests/Variable/TestVariableSync.cpp removed 0 -310

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/FileNotFound.txt removed 0 -3

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/NaNValue.txt removed 0 -6

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/NaNX.txt removed 0 -6

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/NoUnit.txt removed 0 -2

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/TooManyValues.txt removed 0 -6

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/ValidScalar1.txt removed 0 -13

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/ValidVector1.txt removed 0 -12

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/WrongDate.txt removed 0 -6

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/WrongUnit.txt removed 0 -6

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/WrongValue.txt removed 0 -6

NO CONTENT: file was removed

General Comments 2

there is 1 general comment from older versions, show it

perrinel

v2 |

|

Pull request updated. Auto status change to "Under Review"

Changed commits:
  * 2 added
  * 0 removed

Changed files:
  * A core/include/Variable/VariableAcquisitionWorker.h
  * M core/include/Data/IDataProvider.h
  * M core/include/Variable/VariableController.h
  * M core/src/Network/NetworkController.cpp
  * M core/src/Variable/VariableAcquisitionWorker.cpp
  * M core/src/Variable/VariableController.cpp
  * M plugins/amda/src/AmdaProvider.cpp

No TODOs yet

		Pull request updated. Auto status change to \|under_review\|...
`v1 Thu, 21 Sep 2017 18:05:07`
		Auto status change to \|new_status\|...

In pull request description:

No Ticket data found.

In commit messages:

No Ticket data found.

	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