diff --git a/GUI/Models/GUIObjectBuilder.cpp b/GUI/Models/GUIObjectBuilder.cpp
index 643d2da92d0d5d76ed81f3f5cded053e528a5652..1a4dbbaa84569d4b5ec7daed1f589e122e9f1c16 100644
--- a/GUI/Models/GUIObjectBuilder.cpp
+++ b/GUI/Models/GUIObjectBuilder.cpp
@@ -71,19 +71,17 @@ SessionItem* GUI::Model::ObjectBuilder::populateInstrumentModel(InstrumentModel*
SessionItem* GUI::Model::ObjectBuilder::populateDocumentModel(DocumentModel* p_document_model,
const ISimulation& simulation)
{
- auto p_options_item = p_document_model->insertItem<SimulationOptionsItem>();
- if (simulation.options().isIntegrate()) {
- p_options_item->setComputationMethod("Monte-Carlo Integration");
- p_options_item->setNumberOfMonteCarloPoints(
- static_cast<int>(simulation.options().getMcPoints()));
- }
- if (simulation.options().useAvgMaterials()) {
- p_options_item->setFresnelMaterialMethod("Average Layer Material");
- }
- if (simulation.options().includeSpecular()) {
- p_options_item->setIncludeSpecularPeak("Yes");
- }
- return p_options_item;
+ auto* item = p_document_model->insertItem<SimulationOptionsItem>();
+
+ if (simulation.options().isIntegrate())
+ item->setUseMonteCarloIntegration(static_cast<int>(simulation.options().getMcPoints()));
+ else
+ item->setUseAnalytical();
+
+ item->setUseAverageMaterials(simulation.options().useAvgMaterials());
+ item->setIncludeSpecularPeak(simulation.options().includeSpecular());
+
+ return item;
}
namespace {
diff --git a/GUI/Models/SimulationOptionsItem.cpp b/GUI/Models/SimulationOptionsItem.cpp
index 81d9056f023f3e6ca92750854506699a374102c7..40b3f9960f733f8efa9310b63376b30740a8ae55 100644
--- a/GUI/Models/SimulationOptionsItem.cpp
+++ b/GUI/Models/SimulationOptionsItem.cpp
@@ -36,6 +36,14 @@ const QString tooltip_ambientmaterial =
const QString tooltip_specularpeak =
"Defines if the specular peak should be included in the simulation result";
+const QString Immediately = "Immediately";
+const QString InBackground = "In background";
+const QString Analytical = "Analytical";
+const QString MonteCarlo = "Monte-Carlo Integration";
+const QString AmbientLayerMaterial = "Ambient Layer Material";
+const QString AverageLayerMaterial = "Average Layer Material";
+const QString Yes = "Yes";
+const QString No = "No";
} // namespace
const QString SimulationOptionsItem::P_RUN_POLICY = "Run Policy";
@@ -61,21 +69,18 @@ SimulationOptionsItem::SimulationOptionsItem() : SessionItem(M_TYPE)
addProperty(P_NTHREADS, nthreads.variant())->setToolTip(tooltip_nthreads);
ComboProperty computationMethod;
- computationMethod << "Analytical"
- << "Monte-Carlo Integration";
+ computationMethod << Analytical << MonteCarlo;
addProperty(P_COMPUTATION_METHOD, computationMethod.variant())->setToolTip(tooltip_computation);
addProperty(P_MC_POINTS, 100)->setEnabled(false);
ComboProperty averageLayerMaterials;
- averageLayerMaterials << "Ambient Layer Material"
- << "Average Layer Material";
+ averageLayerMaterials << AmbientLayerMaterial << AverageLayerMaterial;
addProperty(P_FRESNEL_MATERIAL_METHOD, averageLayerMaterials.variant())
->setToolTip(tooltip_ambientmaterial);
ComboProperty includeSpecularPeak;
- includeSpecularPeak << "No"
- << "Yes";
+ includeSpecularPeak << No << Yes;
addProperty(P_INCLUDE_SPECULAR_PEAK, includeSpecularPeak.variant())
->setToolTip(tooltip_specularpeak);
@@ -83,34 +88,48 @@ SimulationOptionsItem::SimulationOptionsItem() : SessionItem(M_TYPE)
if (name == P_COMPUTATION_METHOD && isTag(P_MC_POINTS)) {
ComboProperty combo = getItemValue(P_COMPUTATION_METHOD).value<ComboProperty>();
- if (combo.getValue() == "Analytical") {
+ if (combo.getValue() == Analytical)
getItem(P_MC_POINTS)->setEnabled(false);
-
- } else {
+ else
getItem(P_MC_POINTS)->setEnabled(true);
- }
- } else if (name == P_NTHREADS) {
+ } else if (name == P_NTHREADS)
updateComboItem(P_NTHREADS, getCPUUsageOptions());
- } else if (name == P_RUN_POLICY) {
+ else if (name == P_RUN_POLICY)
updateComboItem(P_RUN_POLICY, getRunPolicyNames());
- }
});
}
-int SimulationOptionsItem::getNumberOfThreads() const
+int SimulationOptionsItem::numberOfThreads() const
{
ComboProperty combo = getItemValue(P_NTHREADS).value<ComboProperty>();
return m_text_to_nthreads[combo.getValue()];
}
+void SimulationOptionsItem::setNumberOfThreads(int number)
+{
+ const QString numberAsText = m_text_to_nthreads.key(number);
+ ASSERT(!numberAsText.isEmpty());
+
+ ComboProperty combo = getItemValue(P_NTHREADS).value<ComboProperty>();
+ combo.setValue(numberAsText);
+ setItemValue(P_NTHREADS, combo.variant());
+
+ ASSERT(numberOfThreads() == number);
+}
+
bool SimulationOptionsItem::runImmediately() const
{
- return runPolicy() == "Immediately";
+ return runPolicy() == Immediately;
}
bool SimulationOptionsItem::runInBackground() const
{
- return runPolicy() == "In background";
+ return !runImmediately();
+}
+
+void SimulationOptionsItem::setRunImmediately(bool runImmediately)
+{
+ setRunPolicy(runImmediately ? Immediately : InBackground);
}
void SimulationOptionsItem::setRunPolicy(const QString& policy)
@@ -120,6 +139,22 @@ void SimulationOptionsItem::setRunPolicy(const QString& policy)
setItemValue(P_RUN_POLICY, combo.variant());
}
+void SimulationOptionsItem::setUseMonteCarloIntegration(int numberOfPoints)
+{
+ setComputationMethod(MonteCarlo);
+ setNumberOfMonteCarloPoints(numberOfPoints);
+}
+
+void SimulationOptionsItem::setUseAnalytical()
+{
+ setComputationMethod(Analytical);
+}
+
+bool SimulationOptionsItem::useMonteCarloIntegration() const
+{
+ return getComputationMethod() == MonteCarlo;
+}
+
void SimulationOptionsItem::setComputationMethod(const QString& name)
{
ComboProperty combo = getItemValue(P_COMPUTATION_METHOD).value<ComboProperty>();
@@ -133,7 +168,7 @@ QString SimulationOptionsItem::getComputationMethod() const
return combo.getValue();
}
-int SimulationOptionsItem::getNumberOfMonteCarloPoints() const
+int SimulationOptionsItem::numberOfMonteCarloPoints() const
{
return getItemValue(P_MC_POINTS).toInt();
}
@@ -143,6 +178,16 @@ void SimulationOptionsItem::setNumberOfMonteCarloPoints(int npoints)
setItemValue(P_MC_POINTS, npoints);
}
+void SimulationOptionsItem::setUseAverageMaterials(bool useAverageMaterials)
+{
+ setFresnelMaterialMethod(useAverageMaterials ? AverageLayerMaterial : AmbientLayerMaterial);
+}
+
+bool SimulationOptionsItem::useAverageMaterials() const
+{
+ return getFresnelMaterialMethod() == AverageLayerMaterial;
+}
+
void SimulationOptionsItem::setFresnelMaterialMethod(const QString& name)
{
ComboProperty combo = getItemValue(P_FRESNEL_MATERIAL_METHOD).value<ComboProperty>();
@@ -156,17 +201,17 @@ QString SimulationOptionsItem::getFresnelMaterialMethod() const
return combo.getValue();
}
-void SimulationOptionsItem::setIncludeSpecularPeak(const QString& name)
+void SimulationOptionsItem::setIncludeSpecularPeak(bool includeSpecularPeak)
{
ComboProperty combo = getItemValue(P_INCLUDE_SPECULAR_PEAK).value<ComboProperty>();
- combo.setValue(name);
+ combo.setValue(includeSpecularPeak ? Yes : No);
setItemValue(P_INCLUDE_SPECULAR_PEAK, combo.variant());
}
-QString SimulationOptionsItem::getIncludeSpecularPeak() const
+bool SimulationOptionsItem::includeSpecularPeak() const
{
ComboProperty combo = getItemValue(P_INCLUDE_SPECULAR_PEAK).value<ComboProperty>();
- return combo.getValue();
+ return combo.getValue() == Yes;
}
SessionItem* SimulationOptionsItem::monteCarloPointsItem() const
@@ -204,8 +249,7 @@ QStringList SimulationOptionsItem::getCPUUsageOptions()
QStringList SimulationOptionsItem::getRunPolicyNames()
{
QStringList result;
- result << "Immediately"
- << "In background";
+ result << Immediately << InBackground;
return result;
}
diff --git a/GUI/Models/SimulationOptionsItem.h b/GUI/Models/SimulationOptionsItem.h
index 21a010b25f8dae5dba87fed1d2c32d452b54321b..642c28863cc341392152b7a790c8877a5e3f25fd 100644
--- a/GUI/Models/SimulationOptionsItem.h
+++ b/GUI/Models/SimulationOptionsItem.h
@@ -36,27 +36,37 @@ public:
explicit SimulationOptionsItem();
- int getNumberOfThreads() const;
+ void setNumberOfThreads(int n);
+ int numberOfThreads() const;
+
+ void setRunImmediately(bool runImmediately);
bool runImmediately() const;
bool runInBackground() const;
- void setRunPolicy(const QString& policy);
-
- void setComputationMethod(const QString& name);
- QString getComputationMethod() const;
+ void setUseMonteCarloIntegration(int numberOfPoints);
+ void setUseAnalytical();
+ bool useMonteCarloIntegration() const;
- int getNumberOfMonteCarloPoints() const;
void setNumberOfMonteCarloPoints(int npoints);
+ int numberOfMonteCarloPoints() const;
- void setFresnelMaterialMethod(const QString& name);
- QString getFresnelMaterialMethod() const;
+ void setUseAverageMaterials(bool useAverageMaterials);
+ bool useAverageMaterials() const;
- void setIncludeSpecularPeak(const QString& name);
- QString getIncludeSpecularPeak() const;
+ void setIncludeSpecularPeak(bool includeSpecularPeak);
+ bool includeSpecularPeak() const;
SessionItem* monteCarloPointsItem() const;
private:
+ void setRunPolicy(const QString& policy);
+
+ void setComputationMethod(const QString& name);
+ QString getComputationMethod() const;
+
+ void setFresnelMaterialMethod(const QString& name);
+ QString getFresnelMaterialMethod() const;
+
QString runPolicy() const;
QStringList getCPUUsageOptions();
QStringList getRunPolicyNames();
diff --git a/GUI/Models/TransformToDomain.cpp b/GUI/Models/TransformToDomain.cpp
index 7838b6dac7337ca4d95bd0410b863ae517504f23..aab96e0fd2edcf869a2051da6881cb399ce208c0 100644
--- a/GUI/Models/TransformToDomain.cpp
+++ b/GUI/Models/TransformToDomain.cpp
@@ -171,15 +171,13 @@ void GUI::Transform::ToDomain::setSimulationOptions(ISimulation* simulation,
ASSERT(item.modelType() == SimulationOptionsItem::M_TYPE);
if (auto optionItem = dynamic_cast<const SimulationOptionsItem*>(&item)) {
- simulation->options().setNumberOfThreads(optionItem->getNumberOfThreads());
- if (optionItem->getComputationMethod() == "Monte-Carlo Integration") {
- simulation->options().setMonteCarloIntegration(
- true, optionItem->getNumberOfMonteCarloPoints());
+ simulation->options().setNumberOfThreads(optionItem->numberOfThreads());
+ if (optionItem->useMonteCarloIntegration()) {
+ simulation->options().setMonteCarloIntegration(true,
+ optionItem->numberOfMonteCarloPoints());
}
- if (optionItem->getFresnelMaterialMethod() == "Average Layer Material")
- simulation->options().setUseAvgMaterials(true);
- if (optionItem->getIncludeSpecularPeak() == "Yes")
- simulation->options().setIncludeSpecular(true);
+ simulation->options().setUseAvgMaterials(optionItem->useAverageMaterials());
+ simulation->options().setIncludeSpecular(optionItem->includeSpecularPeak());
}
}
diff --git a/Tests/UnitTests/GUI/TestMapperCases.cpp b/Tests/UnitTests/GUI/TestMapperCases.cpp
index 8f5f1e53df2216b6045a816a4365af4eb9608eca..d0d1757c1ef3d0d13a424b7ede4f509049433e69 100644
--- a/Tests/UnitTests/GUI/TestMapperCases.cpp
+++ b/Tests/UnitTests/GUI/TestMapperCases.cpp
@@ -35,9 +35,9 @@ TEST_F(TestMapperCases, test_SimulationOptionsComputationToggle)
SimulationOptionsItem* item = model.simulationOptionsItem();
- EXPECT_EQ(item->getComputationMethod(), "Analytical");
+ EXPECT_EQ(item->useMonteCarloIntegration(), false);
EXPECT_FALSE(item->monteCarloPointsItem()->isEnabled());
- item->setComputationMethod("Monte-Carlo Integration");
+ item->setUseMonteCarloIntegration(100);
EXPECT_TRUE(item->monteCarloPointsItem()->isEnabled());
}