From 377b3dcc323f7e2efc8f9f320e23bdb41a6b0a87 Mon Sep 17 00:00:00 2001
From: Matthias Puchner <github@mpuchner.de>
Date: Fri, 12 Nov 2021 11:45:12 +0100
Subject: [PATCH] add descriptors to interference items

---
 GUI/Model/Sample/FTDecayFunctionItems.cpp    | 33 +++++++++---
 GUI/Model/Sample/FTDecayFunctionItems.h      | 12 +++--
 GUI/Model/Sample/FTDistributionItems.cpp     | 34 +++++++++---
 GUI/Model/Sample/FTDistributionItems.h       | 11 ++--
 GUI/Model/Sample/InterferenceItems.cpp       | 57 ++++++++++++++------
 GUI/Model/Sample/InterferenceItems.h         | 15 +++---
 GUI/Model/Sample/ParticleLayoutItem.cpp      |  2 +-
 GUI/View/SampleDesigner/LayerEditorUtils.cpp | 10 ++++
 GUI/View/SampleDesigner/LayerEditorUtils.h   |  4 ++
 Tests/Unit/GUI/TestParaCrystalItems.cpp      | 10 ++--
 10 files changed, 141 insertions(+), 47 deletions(-)

diff --git a/GUI/Model/Sample/FTDecayFunctionItems.cpp b/GUI/Model/Sample/FTDecayFunctionItems.cpp
index bd615f93b65..df49062ddad 100644
--- a/GUI/Model/Sample/FTDecayFunctionItems.cpp
+++ b/GUI/Model/Sample/FTDecayFunctionItems.cpp
@@ -104,9 +104,11 @@ DoubleDescriptors FTDecayFunction1DVoigtItem::valueDescriptors() const
 
 // --------------------------------------------------------------------------------------------- //
 
-double FTDecayFunction2DItem::decayLengthX() const
+DoubleDescriptor FTDecayFunction2DItem::decayLengthX() const
 {
-    return getItemValue(P_DECAY_LENGTH_X).toDouble();
+    DoubleDescriptor d(getItem(P_DECAY_LENGTH_X), Unit::nanometer);
+    d.tooltip = "Decay length (half-width of the distribution) along x-axis of the distribution";
+    return d;
 }
 
 void FTDecayFunction2DItem::setDecayLengthX(const double decay_length_x)
@@ -114,9 +116,11 @@ void FTDecayFunction2DItem::setDecayLengthX(const double decay_length_x)
     setItemValue(P_DECAY_LENGTH_X, decay_length_x);
 }
 
-double FTDecayFunction2DItem::decayLengthY() const
+DoubleDescriptor FTDecayFunction2DItem::decayLengthY() const
 {
-    return getItemValue(P_DECAY_LENGTH_Y).toDouble();
+    DoubleDescriptor d(getItem(P_DECAY_LENGTH_Y), Unit::nanometer);
+    d.tooltip = "Decay length (half-width of the distribution) along y-axis of the distribution";
+    return d;
 }
 
 void FTDecayFunction2DItem::setDecayLengthY(const double decay_length_y)
@@ -124,9 +128,11 @@ void FTDecayFunction2DItem::setDecayLengthY(const double decay_length_y)
     setItemValue(P_DECAY_LENGTH_Y, decay_length_y);
 }
 
-double FTDecayFunction2DItem::gamma() const
+DoubleDescriptor FTDecayFunction2DItem::gamma() const
 {
-    return getItemValue(P_GAMMA).toDouble();
+    DoubleDescriptor d(getItem(P_GAMMA), Unit::degree);
+    d.tooltip = "Distribution orientation with respect to the first lattice vector";
+    return d;
 }
 
 void FTDecayFunction2DItem::setGamma(const double gamma)
@@ -134,6 +140,11 @@ void FTDecayFunction2DItem::setGamma(const double gamma)
     setItemValue(P_GAMMA, gamma);
 }
 
+DoubleDescriptors FTDecayFunction2DItem::valueDescriptors() const
+{
+    return {decayLengthX(), decayLengthY(), gamma()};
+}
+
 FTDecayFunction2DItem::FTDecayFunction2DItem(const QString& name) : SessionItem(name) {}
 
 void FTDecayFunction2DItem::add_decay_property()
@@ -206,3 +217,13 @@ void FTDecayFunction2DVoigtItem::setEta(const double eta)
 {
     setItemValue(P_ETA, eta);
 }
+
+DoubleDescriptor FTDecayFunction2DVoigtItem::eta() const
+{
+    return DoubleDescriptor(getItem(P_ETA), Unit::unitless);
+}
+
+DoubleDescriptors FTDecayFunction2DVoigtItem::valueDescriptors() const
+{
+    return {decayLengthX(), decayLengthY(), eta(), gamma()};
+}
diff --git a/GUI/Model/Sample/FTDecayFunctionItems.h b/GUI/Model/Sample/FTDecayFunctionItems.h
index 975a6e3f429..1bf89309575 100644
--- a/GUI/Model/Sample/FTDecayFunctionItems.h
+++ b/GUI/Model/Sample/FTDecayFunctionItems.h
@@ -88,14 +88,17 @@ public:
     virtual std::unique_ptr<IFTDecayFunction2D> createFTDecayFunction() const = 0;
     ~FTDecayFunction2DItem() override = default;
 
-    double decayLengthX() const;
+    DoubleDescriptor decayLengthX() const;
     void setDecayLengthX(double decay_length_x);
-    double decayLengthY() const;
+
+    DoubleDescriptor decayLengthY() const;
     void setDecayLengthY(double decay_length_y);
 
-    double gamma() const;
+    DoubleDescriptor gamma() const;
     void setGamma(double gamma);
 
+    virtual DoubleDescriptors valueDescriptors() const;
+
 protected:
     explicit FTDecayFunction2DItem(const QString& name);
     void add_decay_property();
@@ -129,6 +132,9 @@ public:
     std::unique_ptr<IFTDecayFunction2D> createFTDecayFunction() const override;
 
     void setEta(double eta);
+    DoubleDescriptor eta() const;
+
+    virtual DoubleDescriptors valueDescriptors() const override;
 };
 
 #endif // BORNAGAIN_GUI_MODEL_SAMPLE_FTDECAYFUNCTIONITEMS_H
diff --git a/GUI/Model/Sample/FTDistributionItems.cpp b/GUI/Model/Sample/FTDistributionItems.cpp
index b5ebc68630a..82b52d56d83 100644
--- a/GUI/Model/Sample/FTDistributionItems.cpp
+++ b/GUI/Model/Sample/FTDistributionItems.cpp
@@ -127,9 +127,11 @@ DoubleDescriptors FTDistribution1DVoigtItem::valueDescriptors() const
 
 // --------------------------------------------------------------------------------------------- //
 
-double FTDistribution2DItem::omegaX() const
+DoubleDescriptor FTDistribution2DItem::omegaX() const
 {
-    return getItemValue(P_OMEGA_X).toDouble();
+    DoubleDescriptor d(getItem(P_OMEGA_X), Unit::nanometer);
+    d.tooltip = "Half-width of the distribution along its x-axis";
+    return d;
 }
 
 void FTDistribution2DItem::setOmegaX(const double omega_x)
@@ -137,9 +139,11 @@ void FTDistribution2DItem::setOmegaX(const double omega_x)
     setItemValue(P_OMEGA_X, omega_x);
 }
 
-double FTDistribution2DItem::omegaY() const
+DoubleDescriptor FTDistribution2DItem::omegaY() const
 {
-    return getItemValue(P_OMEGA_Y).toDouble();
+    DoubleDescriptor d(getItem(P_OMEGA_Y), Unit::nanometer);
+    d.tooltip = "Half-width of the distribution along its y-axis";
+    return d;
 }
 
 void FTDistribution2DItem::setOmegaY(const double omega_y)
@@ -147,9 +151,11 @@ void FTDistribution2DItem::setOmegaY(const double omega_y)
     setItemValue(P_OMEGA_Y, omega_y);
 }
 
-double FTDistribution2DItem::gamma() const
+DoubleDescriptor FTDistribution2DItem::gamma() const
 {
-    return getItemValue(P_GAMMA).toDouble();
+    DoubleDescriptor d(getItem(P_GAMMA), Unit::degree);
+    d.tooltip = "Angle in direct space between first lattice vector and x-axis of the distribution";
+    return d;
 }
 
 void FTDistribution2DItem::setGamma(const double gamma)
@@ -157,6 +163,12 @@ void FTDistribution2DItem::setGamma(const double gamma)
     setItemValue(P_GAMMA, gamma);
 }
 
+
+DoubleDescriptors FTDistribution2DItem::valueDescriptors() const
+{
+    return {omegaX(), omegaY(), gamma()};
+}
+
 FTDistribution2DItem::FTDistribution2DItem(const QString& name) : SessionItem(name) {}
 
 void FTDistribution2DItem::add_omega_properties()
@@ -251,7 +263,17 @@ std::unique_ptr<IFTDistribution2D> FTDistribution2DVoigtItem::createFTDistributi
                                                    getItemValue(P_ETA).toDouble());
 }
 
+DoubleDescriptor FTDistribution2DVoigtItem::eta() const
+{
+    return DoubleDescriptor(getItem(P_ETA), Unit::unitless);
+}
+
 void FTDistribution2DVoigtItem::setEta(double eta)
 {
     setItemValue(P_ETA, eta);
 }
+
+DoubleDescriptors FTDistribution2DVoigtItem::valueDescriptors() const
+{
+    return {omegaX(), omegaY(), eta(), gamma()};
+}
diff --git a/GUI/Model/Sample/FTDistributionItems.h b/GUI/Model/Sample/FTDistributionItems.h
index 4b5d37859b7..4517a6ed4bb 100644
--- a/GUI/Model/Sample/FTDistributionItems.h
+++ b/GUI/Model/Sample/FTDistributionItems.h
@@ -102,14 +102,16 @@ private:
 public:
     virtual std::unique_ptr<IFTDistribution2D> createFTDistribution() const = 0;
 
-    double omegaX() const;
+    DoubleDescriptor omegaX() const;
     void setOmegaX(double omega_x);
-    double omegaY() const;
+    DoubleDescriptor omegaY() const;
     void setOmegaY(double omega_y);
 
-    double gamma() const;
+    DoubleDescriptor gamma() const;
     void setGamma(double gamma);
 
+    virtual DoubleDescriptors valueDescriptors() const;
+
 protected:
     explicit FTDistribution2DItem(const QString& name);
     void add_omega_properties();
@@ -159,7 +161,10 @@ public:
     FTDistribution2DVoigtItem();
     std::unique_ptr<IFTDistribution2D> createFTDistribution() const override;
 
+    DoubleDescriptor eta() const;
     void setEta(double eta);
+
+    DoubleDescriptors valueDescriptors() const override;
 };
 
 #endif // BORNAGAIN_GUI_MODEL_SAMPLE_FTDISTRIBUTIONITEMS_H
diff --git a/GUI/Model/Sample/InterferenceItems.cpp b/GUI/Model/Sample/InterferenceItems.cpp
index 9037e688ee5..1287e68227a 100644
--- a/GUI/Model/Sample/InterferenceItems.cpp
+++ b/GUI/Model/Sample/InterferenceItems.cpp
@@ -91,9 +91,9 @@ SelectionDescriptor<FTDecayFunction1DItem*> Interference1DLatticeItem::decayFunc
 
 // --------------------------------------------------------------------------------------------- //
 
-Lattice2DItem* Interference2DAbstractLatticeItem::latticeType() const
+SelectionDescriptor<Lattice2DItem*> Interference2DAbstractLatticeItem::latticeType() const
 {
-    return dynamic_cast<Lattice2DItem*>(getGroupItem(P_LATTICE_TYPE));
+    return SelectionDescriptor<Lattice2DItem*>(item<GroupItem>(P_LATTICE_TYPE));
 }
 
 bool Interference2DAbstractLatticeItem::xiIntegration() const
@@ -138,7 +138,7 @@ Interference2DAbstractLatticeItem::Interference2DAbstractLatticeItem(const QStri
 
 void Interference2DAbstractLatticeItem::update_rotation_availability()
 {
-    auto* p_lattice_item = latticeType();
+    auto* p_lattice_item = latticeType().currentItem();
     if (p_lattice_item) {
         auto* angle_item = p_lattice_item->latticeRotationAngleItem();
         angle_item->setEnabled(!getItemValue(P_XI_INTEGRATION).toBool());
@@ -163,7 +163,7 @@ Interference2DLatticeItem::Interference2DLatticeItem()
 
 std::unique_ptr<IInterference> Interference2DLatticeItem::createInterference() const
 {
-    Lattice2DItem* latticeItem = latticeType();
+    Lattice2DItem* latticeItem = latticeType().currentItem();
     std::unique_ptr<Interference2DLattice> result(
         new Interference2DLattice(*latticeItem->createLattice()));
 
@@ -175,13 +175,18 @@ std::unique_ptr<IInterference> Interference2DLatticeItem::createInterference() c
     return std::unique_ptr<IInterference>(result.release());
 }
 
+SelectionDescriptor<FTDecayFunction2DItem*> Interference2DLatticeItem::decayFunction() const
+{
+    return SelectionDescriptor<FTDecayFunction2DItem*>(item<GroupItem>(P_DECAY_FUNCTION));
+}
+
 // --------------------------------------------------------------------------------------------- //
 
 Interference2DParaCrystalItem::Interference2DParaCrystalItem()
     : Interference2DAbstractLatticeItem(M_TYPE, true)
 {
     setToolTip("Interference function of a two-dimensional paracrystal");
-    latticeType()->latticeRotationAngleItem()->setEnabled(false);
+    latticeType().currentItem()->latticeRotationAngleItem()->setEnabled(false);
 
     addProperty(P_DAMPING_LENGTH, 0.0)
         ->setToolTip("The damping (coherence) length of the paracrystal in nanometers");
@@ -215,7 +220,7 @@ Interference2DParaCrystalItem::Interference2DParaCrystalItem()
 
 std::unique_ptr<IInterference> Interference2DParaCrystalItem::createInterference() const
 {
-    Lattice2DItem* latticeItem = latticeType();
+    Lattice2DItem* latticeItem = latticeType().currentItem();
 
     std::unique_ptr<Interference2DParaCrystal> result(
         new Interference2DParaCrystal(*latticeItem->createLattice(), 0, 0, 0));
@@ -234,9 +239,11 @@ std::unique_ptr<IInterference> Interference2DParaCrystalItem::createInterference
     return std::unique_ptr<IInterference>(result.release());
 }
 
-double Interference2DParaCrystalItem::dampingLength() const
+DoubleDescriptor Interference2DParaCrystalItem::dampingLength() const
 {
-    return getItemValue(P_DAMPING_LENGTH).toDouble();
+    DoubleDescriptor d(getItem(P_DAMPING_LENGTH), Unit::nanometer);
+    d.tooltip = "The damping (coherence) length of the paracrystal";
+    return d;
 }
 
 void Interference2DParaCrystalItem::setDampingLength(const double damping_length)
@@ -244,9 +251,11 @@ void Interference2DParaCrystalItem::setDampingLength(const double damping_length
     setItemValue(P_DAMPING_LENGTH, damping_length);
 }
 
-double Interference2DParaCrystalItem::domainSize1() const
+DoubleDescriptor Interference2DParaCrystalItem::domainSize1() const
 {
-    return getItemValue(P_DOMAIN_SIZE1).toDouble();
+    DoubleDescriptor d(getItem(P_DOMAIN_SIZE1), Unit::nanometer);
+    d.tooltip = "Size of the coherent domain along the first basis vector";
+    return d;
 }
 
 void Interference2DParaCrystalItem::setDomainSize1(const double domain_size1)
@@ -254,9 +263,11 @@ void Interference2DParaCrystalItem::setDomainSize1(const double domain_size1)
     setItemValue(P_DOMAIN_SIZE1, domain_size1);
 }
 
-double Interference2DParaCrystalItem::domainSize2() const
+DoubleDescriptor Interference2DParaCrystalItem::domainSize2() const
 {
-    return getItemValue(P_DOMAIN_SIZE2).toDouble();
+    DoubleDescriptor d(getItem(P_DOMAIN_SIZE2), Unit::nanometer);
+    d.tooltip = "Size of the coherent domain along the second basis vector";
+    return d;
 }
 
 void Interference2DParaCrystalItem::setDomainSize2(const double domain_size2)
@@ -264,14 +275,16 @@ void Interference2DParaCrystalItem::setDomainSize2(const double domain_size2)
     setItemValue(P_DOMAIN_SIZE2, domain_size2);
 }
 
-FTDistribution2DItem* Interference2DParaCrystalItem::pdf1() const
+SelectionDescriptor<FTDistribution2DItem*>
+Interference2DParaCrystalItem::probabilityDistribution1() const
 {
-    return dynamic_cast<FTDistribution2DItem*>(getGroupItem(P_PDF1));
+    return SelectionDescriptor<FTDistribution2DItem*>(item<GroupItem>(P_PDF1));
 }
 
-FTDistribution2DItem* Interference2DParaCrystalItem::pdf2() const
+SelectionDescriptor<FTDistribution2DItem*>
+Interference2DParaCrystalItem::probabilityDistribution2() const
 {
-    return dynamic_cast<FTDistribution2DItem*>(getGroupItem(P_PDF2));
+    return SelectionDescriptor<FTDistribution2DItem*>(item<GroupItem>(P_PDF2));
 }
 
 void Interference2DParaCrystalItem::update_distribution_displaynames()
@@ -308,7 +321,7 @@ InterferenceFinite2DLatticeItem::InterferenceFinite2DLatticeItem()
 
 std::unique_ptr<IInterference> InterferenceFinite2DLatticeItem::createInterference() const
 {
-    Lattice2DItem* latticeItem = latticeType();
+    Lattice2DItem* latticeItem = latticeType().currentItem();
     auto size_1 = getItemValue(P_DOMAIN_SIZE_1).toUInt();
     auto size_2 = getItemValue(P_DOMAIN_SIZE_2).toUInt();
     std::unique_ptr<InterferenceFinite2DLattice> result(
@@ -320,11 +333,21 @@ std::unique_ptr<IInterference> InterferenceFinite2DLatticeItem::createInterferen
     return std::unique_ptr<IInterference>(result.release());
 }
 
+DoubleDescriptor InterferenceFinite2DLatticeItem::domainSize1()
+{
+    return DoubleDescriptor(getItem(P_DOMAIN_SIZE_1), Unit::unitless);
+}
+
 void InterferenceFinite2DLatticeItem::setDomainSize1(const unsigned int domain_size1)
 {
     setItemValue(P_DOMAIN_SIZE_1, domain_size1);
 }
 
+DoubleDescriptor InterferenceFinite2DLatticeItem::domainSize2()
+{
+    return DoubleDescriptor(getItem(P_DOMAIN_SIZE_2), Unit::unitless);
+}
+
 void InterferenceFinite2DLatticeItem::setDomainSize2(const unsigned int domain_size2)
 {
     setItemValue(P_DOMAIN_SIZE_2, domain_size2);
diff --git a/GUI/Model/Sample/InterferenceItems.h b/GUI/Model/Sample/InterferenceItems.h
index 2c78309736f..63b6784b3ed 100644
--- a/GUI/Model/Sample/InterferenceItems.h
+++ b/GUI/Model/Sample/InterferenceItems.h
@@ -65,7 +65,7 @@ private:
     static constexpr auto P_XI_INTEGRATION{"Integration_over_xi"};
 
 public:
-    Lattice2DItem* latticeType() const;
+    SelectionDescriptor<Lattice2DItem*> latticeType() const;
     template <typename T> T* setLatticeType();
 
     bool xiIntegration() const;
@@ -87,6 +87,7 @@ public:
     std::unique_ptr<IInterference> createInterference() const override;
 
     template <typename T> T* setDecayFunctionType();
+    SelectionDescriptor<FTDecayFunction2DItem*> decayFunction() const;
 };
 
 class Interference2DParaCrystalItem : public Interference2DAbstractLatticeItem {
@@ -103,18 +104,18 @@ public:
     Interference2DParaCrystalItem();
     std::unique_ptr<IInterference> createInterference() const override;
 
-    double dampingLength() const;
+    DoubleDescriptor dampingLength() const;
     void setDampingLength(double damping_length);
 
-    double domainSize1() const;
+    DoubleDescriptor domainSize1() const;
     void setDomainSize1(double domain_size1);
-    double domainSize2() const;
+    DoubleDescriptor domainSize2() const;
     void setDomainSize2(double domain_size2);
 
-    FTDistribution2DItem* pdf1() const;
+    SelectionDescriptor<FTDistribution2DItem*> probabilityDistribution1() const;
     template <typename T> T* setPDF1Type();
 
-    FTDistribution2DItem* pdf2() const;
+    SelectionDescriptor<FTDistribution2DItem*> probabilityDistribution2() const;
     template <typename T> T* setPDF2Type();
 
 private:
@@ -132,7 +133,9 @@ public:
     InterferenceFinite2DLatticeItem();
     std::unique_ptr<IInterference> createInterference() const override;
 
+    DoubleDescriptor domainSize1();
     void setDomainSize1(unsigned int domain_size1);
+    DoubleDescriptor domainSize2();
     void setDomainSize2(unsigned int domain_size2);
 };
 
diff --git a/GUI/Model/Sample/ParticleLayoutItem.cpp b/GUI/Model/Sample/ParticleLayoutItem.cpp
index 1470060a8aa..256e40ce5e1 100644
--- a/GUI/Model/Sample/ParticleLayoutItem.cpp
+++ b/GUI/Model/Sample/ParticleLayoutItem.cpp
@@ -169,7 +169,7 @@ void ParticleLayoutItem::updateDensityValue()
     if (auto* interferenceItem = getItem(T_INTERFERENCE)) {
         if (auto* interLatticeItem =
                 dynamic_cast<Interference2DAbstractLatticeItem*>(interferenceItem)) {
-            Lattice2DItem* latticeItem = interLatticeItem->latticeType();
+            Lattice2DItem* latticeItem = interLatticeItem->latticeType().currentItem();
             double area = 0.0;
             try {
                 area = latticeItem->unitCellArea();
diff --git a/GUI/View/SampleDesigner/LayerEditorUtils.cpp b/GUI/View/SampleDesigner/LayerEditorUtils.cpp
index 64963533003..099bc3cc156 100644
--- a/GUI/View/SampleDesigner/LayerEditorUtils.cpp
+++ b/GUI/View/SampleDesigner/LayerEditorUtils.cpp
@@ -160,6 +160,16 @@ DoubleDescriptors LayerEditorUtils::doubleDescriptorsOfItem(RotationItem* item)
     return {};
 }
 
+DoubleDescriptors LayerEditorUtils::doubleDescriptorsOfItem(FTDistribution2DItem* item)
+{
+    return item->valueDescriptors();
+}
+
+DoubleDescriptors LayerEditorUtils::doubleDescriptorsOfItem(FTDecayFunction2DItem* item)
+{
+    return item->valueDescriptors();
+}
+
 DoubleDescriptors LayerEditorUtils::doubleDescriptorsOfItem(FTDistribution1DItem* item)
 {
     return item->valueDescriptors();
diff --git a/GUI/View/SampleDesigner/LayerEditorUtils.h b/GUI/View/SampleDesigner/LayerEditorUtils.h
index 52fde7d7264..71155423026 100644
--- a/GUI/View/SampleDesigner/LayerEditorUtils.h
+++ b/GUI/View/SampleDesigner/LayerEditorUtils.h
@@ -36,6 +36,8 @@ class QWidget;
 class RotationItem;
 class SampleEditorController;
 class VectorDescriptor;
+class FTDecayFunction2DItem;
+class FTDistribution2DItem;
 
 //! Utility functions to support layer oriented sample editor
 namespace LayerEditorUtils {
@@ -76,8 +78,10 @@ DoubleDescriptors doubleDescriptorsOfItem(
     const std::variant<LayerZeroRoughnessItem*, LayerBasicRoughnessItem*>& item);
 
 DoubleDescriptors doubleDescriptorsOfItem(FTDecayFunction1DItem* item);
+DoubleDescriptors doubleDescriptorsOfItem(FTDecayFunction2DItem* item);
 DoubleDescriptors doubleDescriptorsOfItem(FormFactorItem* item);
 DoubleDescriptors doubleDescriptorsOfItem(FTDistribution1DItem* item);
+DoubleDescriptors doubleDescriptorsOfItem(FTDistribution2DItem* item);
 DoubleDescriptors doubleDescriptorsOfItem(RotationItem* item);
 
 QWidget* createWidgetForItemWithParticles(QWidget* parentWidget,
diff --git a/Tests/Unit/GUI/TestParaCrystalItems.cpp b/Tests/Unit/GUI/TestParaCrystalItems.cpp
index b45dad2e15e..97f2de5b54e 100644
--- a/Tests/Unit/GUI/TestParaCrystalItems.cpp
+++ b/Tests/Unit/GUI/TestParaCrystalItems.cpp
@@ -37,7 +37,7 @@ TEST_F(TestParaCrystalItems, Para2DFromToDomain)
     EXPECT_FALSE(orig.integrationOverXi());
     EXPECT_EQ(item.xiIntegration(), orig.integrationOverXi());
 
-    Lattice2DItem* latticeItem = item.latticeType();
+    Lattice2DItem* latticeItem = item.latticeType().currentItem();
     EXPECT_EQ(latticeItem->modelType(), BasicLattice2DItem::M_TYPE);
     auto* basLatticeItem = dynamic_cast<BasicLattice2DItem*>(latticeItem);
     EXPECT_EQ(basLatticeItem->latticeLength1(), length1);
@@ -45,13 +45,13 @@ TEST_F(TestParaCrystalItems, Para2DFromToDomain)
     EXPECT_EQ(basLatticeItem->latticeAngle(), angle);
     EXPECT_EQ(basLatticeItem->latticeRotationAngle(), xi);
 
-    FTDistribution2DItem* pdfItem1 = item.pdf1();
+    FTDistribution2DItem* pdfItem1 = item.probabilityDistribution1().currentItem();
     EXPECT_EQ(pdfItem1->modelType(), FTDistribution2DCauchyItem::M_TYPE);
     EXPECT_EQ(pdfItem1->omegaX(), clength_x);
     EXPECT_EQ(pdfItem1->omegaY(), clength_y);
     EXPECT_EQ(pdfItem1->gamma(), gamma);
 
-    FTDistribution2DItem* pdfItem2 = item.pdf2();
+    FTDistribution2DItem* pdfItem2 = item.probabilityDistribution2().currentItem();
     EXPECT_EQ(pdfItem2->modelType(), FTDistribution2DGaussItem::M_TYPE);
     EXPECT_EQ(pdfItem2->omegaX(), clength_x);
     EXPECT_EQ(pdfItem2->omegaY(), clength_y);
@@ -82,14 +82,14 @@ TEST_F(TestParaCrystalItems, Inference2DRotationAngleToggle)
     // rotation (xi) should be disabled if integration is on
     interference->setXiIntegration(true);
 
-    SessionItem* angleItem = interference->latticeType()->latticeRotationAngleItem();
+    SessionItem* angleItem = interference->latticeType().currentItem()->latticeRotationAngleItem();
 
     EXPECT_FALSE(angleItem->isEnabled());
 
     // rotation (xi) should be enabled if integration is off
     interference->setXiIntegration(false);
 
-    angleItem = interference->latticeType()->latticeRotationAngleItem();
+    angleItem = interference->latticeType().currentItem()->latticeRotationAngleItem();
 
     EXPECT_TRUE(angleItem->isEnabled());
 }
-- 
GitLab