Use string constants for layer roughness item type names

GUI/Models/GroupInfoCatalog.cpp

@@ -23,6 +23,7 @@
 #include "GUI/Models/RealLimitsItems.h"
 #include "GUI/Models/RectangularDetectorItem.h"
 #include "GUI/Models/ResolutionFunctionItems.h"
+#include "GUI/Models/LayerRoughnessItems.h"
 #include "GUI/Models/SphericalDetectorItem.h"
 
 GroupInfoCatalog::GroupInfoCatalog()
@@ -68,9 +69,9 @@ GroupInfoCatalog::GroupInfoCatalog()
     addInfo(info);
 
     info = GroupInfo("Roughness");
-    info.add("LayerBasicRoughness", "Basic");
-    info.add("LayerZeroRoughness", "No");
-    info.setDefaultType("LayerZeroRoughness");
+    info.add(LayerBasicRoughnessItem::M_TYPE, "Basic");
+    info.add(LayerZeroRoughnessItem::M_TYPE, "No");
+    info.setDefaultType(LayerZeroRoughnessItem::M_TYPE);
     addInfo(info);
 
     info = GroupInfo("Detector group");

GUI/Models/ItemCatalog.cpp

@@ -128,8 +128,8 @@ ItemCatalog::ItemCatalog()
     add("ZRotation", create_new<ZRotationItem>);
     add("EulerRotation", create_new<EulerRotationItem>);
 
-    add("LayerBasicRoughness", create_new<LayerBasicRoughnessItem>);
-    add("LayerZeroRoughness", create_new<LayerZeroRoughnessItem>);
+    addItem<LayerBasicRoughnessItem>();
+    addItem<LayerZeroRoughnessItem>();
 
     addItem<SphericalDetectorItem>();
     addItem<RectangularDetectorItem>();

GUI/Models/LayerRoughnessItems.cpp

@@ -20,14 +20,24 @@ const QString hurst_tooltip =
     "dimensionless [0.0, 1.0], where 0.0 gives more spikes, \n1.0 more smoothness.";
 }
 
-LayerZeroRoughnessItem::LayerZeroRoughnessItem() : SessionItem("LayerZeroRoughness") {}
+// Layer zero roughness item
+/* ------------------------------------------------------------------------- */
+
+const QString LayerZeroRoughnessItem::M_TYPE = "LayerZeroRoughness";
+
+LayerZeroRoughnessItem::LayerZeroRoughnessItem() : SessionItem(M_TYPE) {}
+
+// Layer basic roughness item
+/* ------------------------------------------------------------------------- */
 
 const QString LayerBasicRoughnessItem::P_SIGMA = QString::fromStdString("Sigma");
 const QString LayerBasicRoughnessItem::P_HURST = QString::fromStdString("Hurst");
 const QString LayerBasicRoughnessItem::P_LATERAL_CORR_LENGTH =
     QString::fromStdString("CorrelationLength");
 
-LayerBasicRoughnessItem::LayerBasicRoughnessItem() : SessionItem("LayerBasicRoughness")
+const QString LayerBasicRoughnessItem::M_TYPE = "LayerBasicRoughness";
+
+LayerBasicRoughnessItem::LayerBasicRoughnessItem() : SessionItem(M_TYPE)
 {
     setToolTip("A roughness of interface between two layers.");
     addProperty(P_SIGMA, 1.0)->setToolTip("rms of the roughness in nanometers");

GUI/Models/LayerRoughnessItems.h

@@ -19,6 +19,8 @@
 
 class BA_CORE_API_ LayerZeroRoughnessItem : public SessionItem {
 public:
+    static const QString M_TYPE;
+
     LayerZeroRoughnessItem();
 };
 
@@ -27,6 +29,9 @@ public:
     static const QString P_SIGMA;
     static const QString P_HURST;
     static const QString P_LATERAL_CORR_LENGTH;
+
+    static const QString M_TYPE;
+
     LayerBasicRoughnessItem();
 };
 

GUI/Models/TransformFromDomain.cpp

@@ -176,14 +176,15 @@ void TransformFromDomain::setLayerItem(SessionItem* layerItem, const Layer* laye
                                        const LayerInterface* top_interface)
 {
     layerItem->setItemValue(LayerItem::P_THICKNESS, layer->thickness());
-    layerItem->setGroupProperty(LayerItem::P_ROUGHNESS, "LayerZeroRoughness");
+    layerItem->setGroupProperty(LayerItem::P_ROUGHNESS, LayerZeroRoughnessItem::M_TYPE);
     layerItem->setItemValue(LayerItem::P_NSLICES, (int)layer->numberOfSlices());
 
     if (top_interface) {
         const LayerRoughness* roughness = top_interface->getRoughness();
         if (TransformFromDomain::isValidRoughness(roughness)) {
             SessionItem* roughnessItem =
-                layerItem->setGroupProperty(LayerItem::P_ROUGHNESS, "LayerBasicRoughness");
+                layerItem->setGroupProperty(LayerItem::P_ROUGHNESS,
+                                            LayerBasicRoughnessItem::M_TYPE);
             TransformFromDomain::setRoughnessItem(roughnessItem, *roughness);
         }
     }

GUI/Models/TransformToDomain.cpp

@@ -92,9 +92,9 @@ std::unique_ptr<Layer> TransformToDomain::createLayer(const SessionItem& item)
 std::unique_ptr<LayerRoughness>
 TransformToDomain::createLayerRoughness(const SessionItem& roughnessItem)
 {
-    if (roughnessItem.modelType() == "LayerZeroRoughness") {
+    if (roughnessItem.modelType() == LayerZeroRoughnessItem::M_TYPE) {
         return nullptr;
-    } else if (roughnessItem.modelType() == "LayerBasicRoughness") {
+    } else if (roughnessItem.modelType() == LayerBasicRoughnessItem::M_TYPE) {
         return std::make_unique<LayerRoughness>(
             roughnessItem.getItemValue(LayerBasicRoughnessItem::P_SIGMA).toDouble(),
             roughnessItem.getItemValue(LayerBasicRoughnessItem::P_HURST).toDouble(),

Tests/UnitTests/GUI/TestMultiLayerItem.cpp

 #include "GUI/Models/LayerItem.h"
+#include "GUI/Models/LayerRoughnessItems.h"
 #include "GUI/Models/MultiLayerItem.h"
 #include "GUI/Models/SampleModel.h"
 #include "Tests/GTestWrapper/google_test.h"
@@ -31,8 +32,10 @@ TEST_F(TestMultiLayerItem, test_twoLayerSystem)
     EXPECT_TRUE(bottom->getItem(LayerItem::P_ROUGHNESS)->isEnabled());
 
     // Default roughness should be "LayerZeroRoughness"
-    EXPECT_EQ(top->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(), "LayerZeroRoughness");
-    EXPECT_EQ(bottom->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(), "LayerZeroRoughness");
+    EXPECT_EQ(top->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(),
+              LayerZeroRoughnessItem::M_TYPE);
+    EXPECT_EQ(bottom->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(),
+              LayerZeroRoughnessItem::M_TYPE);
 }
 
 //! Testing layer appearance (enabled, disabled) in a MultiLayer made of three default layers.
@@ -64,9 +67,12 @@ TEST_F(TestMultiLayerItem, test_threeLayerSystem)
     EXPECT_TRUE(bottom->getItem(LayerItem::P_ROUGHNESS)->isEnabled());
 
     // Default roughness should be "LayerZeroRoughness"
-    EXPECT_EQ(top->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(), "LayerZeroRoughness");
-    EXPECT_EQ(middle->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(), "LayerZeroRoughness");
-    EXPECT_EQ(bottom->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(), "LayerZeroRoughness");
+    EXPECT_EQ(top->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(),
+              LayerZeroRoughnessItem::M_TYPE);
+    EXPECT_EQ(middle->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(),
+              LayerZeroRoughnessItem::M_TYPE);
+    EXPECT_EQ(bottom->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(),
+              LayerZeroRoughnessItem::M_TYPE);
 }
 
 //! Testing middle layer appearance when it is moved to the top.