##// END OF EJS Templates
HG_REPOSITORIES » LPP » SciQLOP_Repos » SciQLop
RSS
Handles parametric frequency
Alexandre Leroux -
r782:b0b8b5ec2893
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,23
1 #ifndef SCIQLOP_MOCKDEFS_H
2 #define SCIQLOP_MOCKDEFS_H
3
4 #include "MockPluginGlobal.h"
5
6 #include <QString>
7 #include <QVariant>
8
9 // ////////////// //
10 // Mock constants //
11 // ////////////// //
12
13 // Metadata for cosinus provider //
14
15 /// Cosinus frequency (Hz)
16 extern SCIQLOP_MOCKPLUGIN_EXPORT const QString COSINUS_FREQUENCY_KEY;
17 extern SCIQLOP_MOCKPLUGIN_EXPORT const QVariant COSINUS_FREQUENCY_DEFAULT_VALUE;
18
19 /// Cosinus type ("scalar" or "vector")
20 extern SCIQLOP_MOCKPLUGIN_EXPORT const QString COSINUS_TYPE_KEY;
21 extern SCIQLOP_MOCKPLUGIN_EXPORT const QVariant COSINUS_TYPE_DEFAULT_VALUE;
22
23 #endif // SCIQLOP_MOCKDEFS_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,7
1 #include "MockDefs.h"
2
3 const QString COSINUS_FREQUENCY_KEY = QStringLiteral("cosinusFrequency");
4 const QVariant COSINUS_FREQUENCY_DEFAULT_VALUE = 60.;
5
6 const QString COSINUS_TYPE_KEY = QStringLiteral("cosinusType");
7 const QVariant COSINUS_TYPE_DEFAULT_VALUE = QStringLiteral("scalar");
Show file before | Show file after | Hide comments
@@ -1,116 +1,124
1 1 #include "CosinusProvider.h"
2 #include "MockDefs.h"
2 3
3 4 #include <Data/DataProviderParameters.h>
4 5 #include <Data/ScalarSeries.h>
5 6
6 7 #include <cmath>
7 8
8 9 #include <QFuture>
9 10 #include <QThread>
10 11 #include <QtConcurrent/QtConcurrent>
11 12
12 13 Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
13 14
14 15 std::shared_ptr<IDataProvider> CosinusProvider::clone() const
15 16 {
16 17 // No copy is made in clone
17 18 return std::make_shared<CosinusProvider>();
18 19 }
19 20
20 21 std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
21 22 const SqpRange &dataRangeRequested,
22 23 const QVariantHash &data)
23 24 {
24 25 // TODO: Add Mutex
25 26 auto dataIndex = 0;
26 27
28 // Retrieves frequency
29 auto freqVariant = data.value(COSINUS_FREQUENCY_KEY, COSINUS_FREQUENCY_DEFAULT_VALUE);
30 if (!freqVariant.canConvert<double>()) {
31 qCCritical(LOG_CosinusProvider()) << tr("Can't retrieve data: invalid frequency");
32 return nullptr;
33 }
34
27 35 // Gets the timerange from the parameters
28 double freq = 100.0;
29 double start = std::ceil(dataRangeRequested.m_TStart * freq); // 100 htz
30 double end = std::floor(dataRangeRequested.m_TEnd * freq); // 100 htz
36 double freq = freqVariant.toDouble();
37 double start = std::ceil(dataRangeRequested.m_TStart * freq);
38 double end = std::floor(dataRangeRequested.m_TEnd * freq);
31 39
32 40 // We assure that timerange is valid
33 41 if (end < start) {
34 42 std::swap(start, end);
35 43 }
36 44
37 45 // Generates scalar series containing cosinus values (one value per second, end value is
38 46 // included)
39 47 auto dataCount = end - start + 1;
40 48
41 49 auto xAxisData = std::vector<double>{};
42 50 xAxisData.resize(dataCount);
43 51
44 52 auto valuesData = std::vector<double>{};
45 53 valuesData.resize(dataCount);
46 54
47 55 int progress = 0;
48 56 auto progressEnd = dataCount;
49 57 for (auto time = start; time <= end; ++time, ++dataIndex) {
50 58 auto it = m_VariableToEnableProvider.find(acqIdentifier);
51 59 if (it != m_VariableToEnableProvider.end() && it.value()) {
52 60 const auto timeOnFreq = time / freq;
53 61
54 62 xAxisData[dataIndex] = timeOnFreq;
55 63 valuesData[dataIndex] = std::cos(timeOnFreq);
56 64
57 65 // progression
58 66 int currentProgress = (time - start) * 100.0 / progressEnd;
59 67 if (currentProgress != progress) {
60 68 progress = currentProgress;
61 69
62 70 emit dataProvidedProgress(acqIdentifier, progress);
63 71 qCInfo(LOG_CosinusProvider()) << "TORM: CosinusProvider::retrieveData"
64 72 << QThread::currentThread()->objectName() << progress;
65 73 // NOTE: Try to use multithread if possible
66 74 }
67 75 }
68 76 else {
69 77 if (!it.value()) {
70 78 qCDebug(LOG_CosinusProvider())
71 79 << "CosinusProvider::retrieveData: ARRET De l'acquisition detectΓ©"
72 80 << end - time;
73 81 }
74 82 }
75 83 }
76 84 if (progress != 100) {
77 85 // We can close progression beacause all data has been retrieved
78 86 emit dataProvidedProgress(acqIdentifier, 100);
79 87 }
80 88 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
81 89 Unit{QStringLiteral("t"), true}, Unit{});
82 90 }
83 91
84 92 void CosinusProvider::requestDataLoading(QUuid acqIdentifier,
85 93 const DataProviderParameters &parameters)
86 94 {
87 95 // TODO: Add Mutex
88 96 m_VariableToEnableProvider[acqIdentifier] = true;
89 97 qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::requestDataLoading"
90 98 << QThread::currentThread()->objectName();
91 99 // NOTE: Try to use multithread if possible
92 100 const auto times = parameters.m_Times;
93 101
94 102 for (const auto &dateTime : qAsConst(times)) {
95 103 if (m_VariableToEnableProvider[acqIdentifier]) {
96 104 auto scalarSeries = this->retrieveData(acqIdentifier, dateTime, parameters.m_Data);
97 105 qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::dataProvided";
98 106 emit dataProvided(acqIdentifier, scalarSeries, dateTime);
99 107 }
100 108 }
101 109 }
102 110
103 111 void CosinusProvider::requestDataAborting(QUuid acqIdentifier)
104 112 {
105 113 // TODO: Add Mutex
106 114 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << acqIdentifier
107 115 << QThread::currentThread()->objectName();
108 116 auto it = m_VariableToEnableProvider.find(acqIdentifier);
109 117 if (it != m_VariableToEnableProvider.end()) {
110 118 it.value() = false;
111 119 }
112 120 else {
113 121 qCWarning(LOG_CosinusProvider())
114 122 << tr("Aborting progression of inexistant identifier detected !!!");
115 123 }
116 124 }
Show file before | Show file after | Hide comments
@@ -1,79 +1,81
1 1 #include "MockPlugin.h"
2 2 #include "CosinusProvider.h"
3 #include "MockDefs.h"
3 4
4 5 #include <DataSource/DataSourceController.h>
5 6 #include <DataSource/DataSourceItem.h>
6 7 #include <DataSource/DataSourceItemAction.h>
7 8
8 9 #include <SqpApplication.h>
9 10
10 11 Q_LOGGING_CATEGORY(LOG_MockPlugin, "MockPlugin")
11 12
12 13 namespace {
13 14
14 15 /// Name of the data source
15 16 const auto DATA_SOURCE_NAME = QStringLiteral("MMS");
16 17
17 18 /// Creates the data provider relative to the plugin
18 19 std::unique_ptr<IDataProvider> createDataProvider() noexcept
19 20 {
20 21 return std::make_unique<CosinusProvider>();
21 22 }
22 23
23 std::unique_ptr<DataSourceItem> createProductItem(const QString &productName,
24 std::unique_ptr<DataSourceItem> createProductItem(const QVariantHash &data,
24 25 const QUuid &dataSourceUid)
25 26 {
26 auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, productName);
27 auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, data);
28 auto productName = data.value(DataSourceItem::NAME_DATA_KEY).toString();
27 29
28 30 // Add action to load product from DataSourceController
29 31 result->addAction(std::make_unique<DataSourceItemAction>(
30 32 QObject::tr("Load %1 product").arg(productName),
31 33 [productName, dataSourceUid](DataSourceItem &item) {
32 34 if (auto app = sqpApp) {
33 35 app->dataSourceController().loadProductItem(dataSourceUid, item);
34 36 }
35 37 }));
36 38
37 39 return result;
38 40 }
39 41
40 42 /// Creates the data source item relative to the plugin
41 43 std::unique_ptr<DataSourceItem> createDataSourceItem(const QUuid &dataSourceUid) noexcept
42 44 {
43 45 // Magnetic field products
44 46 auto magneticFieldFolder = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
45 47 QStringLiteral("Magnetic field"));
46 48 magneticFieldFolder->appendChild(createProductItem(QStringLiteral("FGM"), dataSourceUid));
47 49 magneticFieldFolder->appendChild(createProductItem(QStringLiteral("SC"), dataSourceUid));
48 50
49 51 // Electric field products
50 52 auto electricFieldFolder = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
51 53 QStringLiteral("Electric field"));
52 54
53 55 // Root
54 56 auto root = std::make_unique<DataSourceItem>(DataSourceItemType::NODE, DATA_SOURCE_NAME);
55 57 root->appendChild(std::move(magneticFieldFolder));
56 58 root->appendChild(std::move(electricFieldFolder));
57 59
58 60 return root;
59 61 }
60 62
61 63 } // namespace
62 64
63 65 void MockPlugin::initialize()
64 66 {
65 67 if (auto app = sqpApp) {
66 68 // Registers to the data source controller
67 69 auto &dataSourceController = app->dataSourceController();
68 70 auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
69 71
70 72 // Sets data source tree
71 73 dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem(dataSourceUid));
72 74
73 75 // Sets data provider
74 76 dataSourceController.setDataProvider(dataSourceUid, createDataProvider());
75 77 }
76 78 else {
77 79 qCWarning(LOG_MockPlugin()) << tr("Can't access to SciQlop application");
78 80 }
79 81 }
General Comments 0
You need to be logged in to leave comments. Login now