Switch to the new beam divergence machinery in the GUI

GUI/coregui/Models/DomainSimulationBuilder.cpp

@@ -158,12 +158,11 @@ createSpecularSimulation(std::unique_ptr<MultiLayer> P_multilayer,
     AngularSpecScan scan(beam_item->getWavelength(), *axis_item->createAxis(Units::degree));
     scan.setFootprintFactor(footprint->createFootprint().get());
 
+    TransformToDomain::addBeamDivergencesToScan(*beam_item, scan);
+
     specular_simulation->setBeamIntensity(beam_item->getIntensity());
     specular_simulation->setScan(scan);
 
-    TransformToDomain::addDistributionParametersToSimulation(*beam_item,
-                                                             *specular_simulation.get());
-
     // Simulation options
     if (options_item)
         TransformToDomain::setSimulationOptions(specular_simulation.get(), *options_item);

GUI/coregui/Models/DomainSimulationBuilder.h

@@ -32,7 +32,7 @@ namespace DomainSimulationBuilder
 
 BA_CORE_API_ std::unique_ptr<Simulation> createSimulation(const MultiLayerItem* sampleItem,
                                             const InstrumentItem* instrumentItem,
-                                            const SimulationOptionsItem* optionsItem = 0);
+                                            const SimulationOptionsItem* optionsItem = nullptr);
 };
 
 #endif // DOMAINSIMULATIONBUILDER_H

GUI/coregui/Models/TransformToDomain.cpp

@@ -45,11 +45,13 @@
 #include "ParticleDistributionItem.h"
 #include "ParticleItem.h"
 #include "ParticleLayoutItem.h"
+#include "RangedDistributions.h"
 #include "RotationItems.h"
+#include "ScanResolution.h"
 #include "SessionItemUtils.h"
 #include "SimulationOptionsItem.h"
+#include "AngularSpecScan.h"
 #include "SpecularBeamInclinationItem.h"
-#include "SpecularSimulation.h"
 #include "TransformationItem.h"
 #include "Units.h"
 #include "VectorItem.h"
@@ -61,6 +63,8 @@ namespace
 template <class T>
 void setParameterDistributionToSimulation(const std::string& parameter_name,
                                           const SessionItem* item, Simulation& simulation);
+
+std::unique_ptr<ScanResolution> createScanResolution(const SessionItem* item);
 }
 
 std::unique_ptr<Material>
@@ -166,25 +170,22 @@ void TransformToDomain::addDistributionParametersToSimulation(const SessionItem&
         BornAgain::Azimuth, beam_item.getItem(BeamItem::P_AZIMUTHAL_ANGLE), simulation);
 }
 
-void TransformToDomain::addDistributionParametersToSimulation(const SessionItem& beam_item,
-                                                              SpecularSimulation& simulation)
+void TransformToDomain::addBeamDivergencesToScan(const SessionItem& beam_item,
+                                                 AngularSpecScan& scan)
 {
     if (beam_item.modelType() != Constants::SpecularBeamType) {
         Q_ASSERT(beam_item.modelType() == Constants::SpecularBeamType);
         return;
     }
 
-    setParameterDistributionToSimulation<BeamWavelengthItem>(
-        BornAgain::Wavelength, beam_item.getItem(SpecularBeamItem::P_WAVELENGTH), simulation);
-    setParameterDistributionToSimulation<SpecularBeamInclinationItem>(
-        BornAgain::Inclination, beam_item.getItem(SpecularBeamItem::P_INCLINATION_ANGLE),
-        simulation);
+    auto resolution = createScanResolution(beam_item.getItem(SpecularBeamItem::P_WAVELENGTH));
+    if (resolution)
+        scan.setWavelengthResolution(*resolution);
+    resolution = createScanResolution(beam_item.getItem(SpecularBeamItem::P_INCLINATION_ANGLE));
+    if (resolution)
+        scan.setAngleResolution(*resolution);
 }
 
-// TODO Consider removal addDistributionParametersToSimulation and
-// template <class T> void setParameterDistributionToSimulation in the favor
-// of setBeamDistribution.
-
 void TransformToDomain::setBeamDistribution(const std::string& parameter_name,
                               const BeamDistributionItem& item, Simulation& simulation)
 {
@@ -259,4 +260,25 @@ void setParameterDistributionToSimulation(const std::string& parameter_name,
     if (P_par_distr)
         simulation.addParameterDistribution(*P_par_distr);
 }
+
+std::unique_ptr<ScanResolution> createScanResolution(const SessionItem* item)
+{
+    auto beam_item = dynamic_cast<const BeamDistributionItem*>(item);
+    if (!beam_item)
+        return nullptr;
+
+    auto distr_item = dynamic_cast<const SymmetricDistributionItem*>(
+        beam_item->getGroupItem(BeamDistributionItem::P_DISTRIBUTION));
+    if (!distr_item)
+        return nullptr;
+
+    const double scale = beam_item->scaleFactor();
+    auto ranged_distr = distr_item->createRangedDistribution(scale);
+    if (!ranged_distr)
+        return nullptr;
+
+    const double deviation = distr_item->deviation(scale);
+    return std::unique_ptr<ScanResolution>(
+        ScanResolution::scanAbsoluteResolution(*ranged_distr, deviation));
+}
 }

GUI/coregui/Models/TransformToDomain.h

@@ -27,13 +27,13 @@
 #include "ParticleLayout.h"
 #include <memory>
 
-class DetectorItem;
+class AngularSpecScan;
+class BeamDistributionItem;
 class GISASSimulation;
 class Material;
 class MaterialItemContainer;
 class SessionItem;
 class Simulation;
-class BeamDistributionItem;
 
 namespace TransformToDomain
 {
@@ -48,8 +48,8 @@ BA_CORE_API_ std::unique_ptr<ParticleLayout> createParticleLayout(const SessionI
 
 BA_CORE_API_ void addDistributionParametersToSimulation(
     const SessionItem& beam_item, GISASSimulation& simulation);
-BA_CORE_API_ void addDistributionParametersToSimulation(
-    const SessionItem& beam_item, SpecularSimulation& simulation);
+BA_CORE_API_ void addBeamDivergencesToScan(const SessionItem& beam_item,
+                                           AngularSpecScan& simulation);
 
 BA_CORE_API_ void setBeamDistribution(const std::string& parameter_name,
         const BeamDistributionItem& item, Simulation& simulation);