From f22be094076dcce51b2aeeff3e0e040c9d51bf1b Mon Sep 17 00:00:00 2001
From: Walter Van Herck <w.van.herck@fz-juelich.de>
Date: Wed, 29 Nov 2017 17:31:32 +0100
Subject: [PATCH] Add constant background test to Core/GUI/Python-StandardTest
---
Core/StandardSamples/SimulationFactory.cpp | 6 +
Core/StandardSamples/StandardSimulations.cpp | 9 ++
Core/StandardSamples/StandardSimulations.h | 1 +
GUI/coregui/Models/TransformFromDomain.cpp | 137 +++++++++---------
GUI/coregui/Models/TransformFromDomain.h | 65 +++++----
.../Core/CoreStandardTest/CMakeLists.txt | 1 +
.../GUI/GUIStandardTest/CMakeLists.txt | 1 +
.../Python/PyStandard/CMakeLists.txt | 1 +
.../TestMachinery/StandardTestCatalogue.cpp | 8 +
.../StandardSuite/ConstantBackground.int.gz | Bin 0 -> 2128 bytes
10 files changed, 130 insertions(+), 99 deletions(-)
create mode 100644 Tests/ReferenceData/StandardSuite/ConstantBackground.int.gz
diff --git a/Core/StandardSamples/SimulationFactory.cpp b/Core/StandardSamples/SimulationFactory.cpp
index 186242a42a3..015f1a22a7e 100644
--- a/Core/StandardSamples/SimulationFactory.cpp
+++ b/Core/StandardSamples/SimulationFactory.cpp
@@ -124,6 +124,12 @@ SimulationFactory::SimulationFactory()
StandardSimulations::RectDetWithRoi,
"Rectangular detector with ROI and mask");
+ // background
+
+ registerItem("ConstantBackground",
+ StandardSimulations::ConstantBackgroundGISAS,
+ "Simulation with a constant background value");
+
// specular simulations
registerItem("BasicSpecular",
diff --git a/Core/StandardSamples/StandardSimulations.cpp b/Core/StandardSamples/StandardSimulations.cpp
index 80515842905..0721fd13275 100644
--- a/Core/StandardSamples/StandardSimulations.cpp
+++ b/Core/StandardSamples/StandardSimulations.cpp
@@ -15,6 +15,7 @@
#include "StandardSimulations.h"
#include "BornAgainNamespace.h"
+#include <ConstantBackground.h>
#include "Distributions.h"
#include "Ellipse.h"
#include "GISASSimulation.h"
@@ -378,3 +379,11 @@ SpecularSimulation* StandardSimulations::BasicSpecular()
result->setBeamParameters(wavelength, number_of_bins, min_angle, max_angle);
return result.release();
}
+
+GISASSimulation*StandardSimulations::ConstantBackgroundGISAS()
+{
+ GISASSimulation* result = MiniGISAS();
+ ConstantBackground bg(1e3);
+ result->setBackground(bg);
+ return result;
+}
diff --git a/Core/StandardSamples/StandardSimulations.h b/Core/StandardSamples/StandardSimulations.h
index 347957a432a..cc006ac6aac 100644
--- a/Core/StandardSamples/StandardSimulations.h
+++ b/Core/StandardSamples/StandardSimulations.h
@@ -50,6 +50,7 @@ GISASSimulation* RectDetectorPerpToReflectedBeamDpos();
GISASSimulation* MiniGISASMonteCarlo();
GISASSimulation* SphericalDetWithRoi();
GISASSimulation* RectDetWithRoi();
+GISASSimulation* ConstantBackgroundGISAS();
// Specular simulation tests:
SpecularSimulation* BasicSpecular();
diff --git a/GUI/coregui/Models/TransformFromDomain.cpp b/GUI/coregui/Models/TransformFromDomain.cpp
index 8e72a019641..a3810c6523d 100644
--- a/GUI/coregui/Models/TransformFromDomain.cpp
+++ b/GUI/coregui/Models/TransformFromDomain.cpp
@@ -21,6 +21,7 @@
#include "BeamItem.h"
#include "BornAgainNamespace.h"
#include "ComboProperty.h"
+#include "ConstantBackground.h"
#include "ConvolutionDetectorResolution.h"
#include "DetectorItems.h"
#include "SphericalDetectorItem.h"
@@ -202,15 +203,15 @@ bool TransformFromDomain::isValidRoughness(const LayerRoughness* roughness)
return true;
}
-void TransformFromDomain::setItemFromSample(BeamItem* beamItem, const GISASSimulation& simulation)
+void TransformFromDomain::setItemFromSample(BeamItem* beam_item, const GISASSimulation& simulation)
{
- Q_ASSERT(beamItem);
+ Q_ASSERT(beam_item);
Beam beam = simulation.getInstrument().getBeam();
- beamItem->setIntensity(beam.getIntensity());
- beamItem->setWavelength(beam.getWavelength());
- beamItem->setInclinationAngle(Units::rad2deg(beam.getAlpha()));
- beamItem->setAzimuthalAngle(Units::rad2deg(beam.getPhi()));
+ beam_item->setIntensity(beam.getIntensity());
+ beam_item->setWavelength(beam.getWavelength());
+ beam_item->setInclinationAngle(Units::rad2deg(beam.getAlpha()));
+ beam_item->setAzimuthalAngle(Units::rad2deg(beam.getPhi()));
// distribution parameters
const DistributionHandler::Distributions_t distributions
@@ -225,38 +226,38 @@ void TransformFromDomain::setItemFromSample(BeamItem* beamItem, const GISASSimul
std::string mainParameterName = distributions[i].getMainParameterName();
if (mainParameterName == pattern_wavelength.toStdString()) {
BeamDistributionItem* beamWavelength = dynamic_cast<BeamDistributionItem*>(
- beamItem->getItem(BeamItem::P_WAVELENGTH));
+ beam_item->getItem(BeamItem::P_WAVELENGTH));
setItemFromSample(beamWavelength, distributions[i]);
} else if (mainParameterName == pattern_alpha.toStdString()) {
BeamDistributionItem* inclinationAngle = dynamic_cast<BeamDistributionItem*>(
- beamItem->getItem(BeamItem::P_INCLINATION_ANGLE));
+ beam_item->getItem(BeamItem::P_INCLINATION_ANGLE));
setItemFromSample(inclinationAngle, distributions[i]);
} else if (mainParameterName == pattern_phi.toStdString()) {
BeamDistributionItem* azimuthalAngle = dynamic_cast<BeamDistributionItem*>(
- beamItem->getItem(BeamItem::P_AZIMUTHAL_ANGLE));
+ beam_item->getItem(BeamItem::P_AZIMUTHAL_ANGLE));
setItemFromSample(azimuthalAngle, distributions[i]);
}
}
// polarization parameters
- SetVectorItem(*beamItem, BeamItem::P_POLARIZATION, beam.getBlochVector());
+ SetVectorItem(*beam_item, BeamItem::P_POLARIZATION, beam.getBlochVector());
}
-void TransformFromDomain::setInstrumentDetectorFromSample(InstrumentItem* instrumentItem,
+void TransformFromDomain::setInstrumentDetectorFromSample(InstrumentItem* instrument_item,
const GISASSimulation& simulation)
{
const IDetector* p_detector = simulation.getInstrument().getDetector();
DetectorItem* detector_item;
if(auto detector = dynamic_cast<const SphericalDetector*>(p_detector)) {
- instrumentItem->setDetectorGroup(Constants::SphericalDetectorType);
- detector_item = instrumentItem->detectorItem();
+ instrument_item->setDetectorGroup(Constants::SphericalDetectorType);
+ detector_item = instrument_item->detectorItem();
auto item = dynamic_cast<SphericalDetectorItem*>(detector_item);
setItemFromSample(item, *detector);
}
else if(auto detector = dynamic_cast<const RectangularDetector*>(p_detector)) {
- instrumentItem->setDetectorGroup(Constants::RectangularDetectorType);
- detector_item = instrumentItem->detectorItem();
+ instrument_item->setDetectorGroup(Constants::RectangularDetectorType);
+ detector_item = instrument_item->detectorItem();
auto item = dynamic_cast<RectangularDetectorItem*>(detector_item);
setItemFromSample(item, *detector);
}
@@ -307,7 +308,7 @@ void TransformFromDomain::setInstrumentDetectorFromSample(InstrumentItem* instru
}
}
-void TransformFromDomain::setItemFromSample(SphericalDetectorItem* detectorItem,
+void TransformFromDomain::setItemFromSample(SphericalDetectorItem* detector_item,
const SphericalDetector& detector)
{
// Axes
@@ -315,14 +316,14 @@ void TransformFromDomain::setItemFromSample(SphericalDetectorItem* detectorItem,
const IAxis& alpha_axis = detector.getAxis(1);
BasicAxisItem* phiAxisItem = dynamic_cast<BasicAxisItem*>(
- detectorItem->getItem(SphericalDetectorItem::P_PHI_AXIS));
+ detector_item->getItem(SphericalDetectorItem::P_PHI_AXIS));
Q_ASSERT(phiAxisItem);
phiAxisItem->setItemValue(BasicAxisItem::P_NBINS, (int)phi_axis.size());
phiAxisItem->setItemValue(BasicAxisItem::P_MIN, Units::rad2deg(phi_axis.getMin()));
phiAxisItem->setItemValue(BasicAxisItem::P_MAX, Units::rad2deg(phi_axis.getMax()));
BasicAxisItem* alphaAxisItem = dynamic_cast<BasicAxisItem*>(
- detectorItem->getItem(SphericalDetectorItem::P_ALPHA_AXIS));
+ detector_item->getItem(SphericalDetectorItem::P_ALPHA_AXIS));
Q_ASSERT(alphaAxisItem);
alphaAxisItem->setItemValue(BasicAxisItem::P_NBINS, (int)alpha_axis.size());
alphaAxisItem->setItemValue(BasicAxisItem::P_MIN, Units::rad2deg(alpha_axis.getMin()));
@@ -330,67 +331,67 @@ void TransformFromDomain::setItemFromSample(SphericalDetectorItem* detectorItem,
}
-void TransformFromDomain::setItemFromSample(RectangularDetectorItem* detectorItem,
+void TransformFromDomain::setItemFromSample(RectangularDetectorItem* detector_item,
const RectangularDetector& detector)
{
// Axes
BasicAxisItem* xAxisItem = dynamic_cast<BasicAxisItem*>(
- detectorItem->getItem(RectangularDetectorItem::P_X_AXIS));
+ detector_item->getItem(RectangularDetectorItem::P_X_AXIS));
Q_ASSERT(xAxisItem);
xAxisItem->setItemValue(BasicAxisItem::P_NBINS, (int)detector.getNbinsX());
xAxisItem->setItemValue(BasicAxisItem::P_MAX, detector.getWidth());
BasicAxisItem* yAxisItem = dynamic_cast<BasicAxisItem*>(
- detectorItem->getItem(RectangularDetectorItem::P_Y_AXIS));
+ detector_item->getItem(RectangularDetectorItem::P_Y_AXIS));
Q_ASSERT(yAxisItem);
yAxisItem->setItemValue(BasicAxisItem::P_NBINS, (int)detector.getNbinsY());
yAxisItem->setItemValue(BasicAxisItem::P_MAX, detector.getHeight());
if(detector.getDetectorArrangment() == RectangularDetector::GENERIC) {
- detectorItem->setDetectorAlignment(Constants::ALIGNMENT_GENERIC);
+ detector_item->setDetectorAlignment(Constants::ALIGNMENT_GENERIC);
kvector_t normal = detector.getNormalVector();
- SetVectorItem(*detectorItem, RectangularDetectorItem::P_NORMAL, normal);
+ SetVectorItem(*detector_item, RectangularDetectorItem::P_NORMAL, normal);
kvector_t direction = detector.getDirectionVector();
- SetVectorItem(*detectorItem, RectangularDetectorItem::P_DIRECTION,
+ SetVectorItem(*detector_item, RectangularDetectorItem::P_DIRECTION,
direction);
- detectorItem->setItemValue(RectangularDetectorItem::P_U0, detector.getU0());
- detectorItem->setItemValue(RectangularDetectorItem::P_V0, detector.getV0());
+ detector_item->setItemValue(RectangularDetectorItem::P_U0, detector.getU0());
+ detector_item->setItemValue(RectangularDetectorItem::P_V0, detector.getV0());
}
else if (detector.getDetectorArrangment() == RectangularDetector::PERPENDICULAR_TO_SAMPLE) {
- detectorItem->setDetectorAlignment(Constants::ALIGNMENT_TO_SAMPLE);
- detectorItem->setItemValue(RectangularDetectorItem::P_DISTANCE,
+ detector_item->setDetectorAlignment(Constants::ALIGNMENT_TO_SAMPLE);
+ detector_item->setItemValue(RectangularDetectorItem::P_DISTANCE,
detector.getDistance());
- detectorItem->setItemValue(RectangularDetectorItem::P_U0, detector.getU0());
- detectorItem->setItemValue(RectangularDetectorItem::P_V0, detector.getV0());
+ detector_item->setItemValue(RectangularDetectorItem::P_U0, detector.getU0());
+ detector_item->setItemValue(RectangularDetectorItem::P_V0, detector.getV0());
} else if (detector.getDetectorArrangment()
== RectangularDetector::PERPENDICULAR_TO_DIRECT_BEAM) {
- detectorItem->setDetectorAlignment(Constants::ALIGNMENT_TO_DIRECT_BEAM);
- detectorItem->setItemValue(RectangularDetectorItem::P_DISTANCE,
+ detector_item->setDetectorAlignment(Constants::ALIGNMENT_TO_DIRECT_BEAM);
+ detector_item->setItemValue(RectangularDetectorItem::P_DISTANCE,
detector.getDistance());
- detectorItem->setItemValue(RectangularDetectorItem::P_DBEAM_U0, detector.getU0());
- detectorItem->setItemValue(RectangularDetectorItem::P_DBEAM_V0, detector.getV0());
+ detector_item->setItemValue(RectangularDetectorItem::P_DBEAM_U0, detector.getU0());
+ detector_item->setItemValue(RectangularDetectorItem::P_DBEAM_V0, detector.getV0());
} else if (detector.getDetectorArrangment()
== RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM) {
- detectorItem->setDetectorAlignment(Constants::ALIGNMENT_TO_REFLECTED_BEAM);
- detectorItem->setItemValue(RectangularDetectorItem::P_DISTANCE,
+ detector_item->setDetectorAlignment(Constants::ALIGNMENT_TO_REFLECTED_BEAM);
+ detector_item->setItemValue(RectangularDetectorItem::P_DISTANCE,
detector.getDistance());
- detectorItem->setItemValue(RectangularDetectorItem::P_U0, detector.getU0());
- detectorItem->setItemValue(RectangularDetectorItem::P_V0, detector.getV0());
+ detector_item->setItemValue(RectangularDetectorItem::P_U0, detector.getU0());
+ detector_item->setItemValue(RectangularDetectorItem::P_V0, detector.getV0());
} else if (detector.getDetectorArrangment()
== RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM_DPOS) {
- detectorItem->setDetectorAlignment(Constants::ALIGNMENT_TO_REFLECTED_BEAM_DPOS);
- detectorItem->setItemValue(RectangularDetectorItem::P_DISTANCE,
+ detector_item->setDetectorAlignment(Constants::ALIGNMENT_TO_REFLECTED_BEAM_DPOS);
+ detector_item->setItemValue(RectangularDetectorItem::P_DISTANCE,
detector.getDistance());
- detectorItem->setItemValue(RectangularDetectorItem::P_DBEAM_U0,
+ detector_item->setItemValue(RectangularDetectorItem::P_DBEAM_U0,
detector.getDirectBeamU0());
- detectorItem->setItemValue(RectangularDetectorItem::P_DBEAM_V0,
+ detector_item->setItemValue(RectangularDetectorItem::P_DBEAM_V0,
detector.getDirectBeamV0());
} else {
@@ -400,23 +401,23 @@ void TransformFromDomain::setItemFromSample(RectangularDetectorItem* detectorIte
}
}
-void TransformFromDomain::setDetectorMasks(DetectorItem* detectorItem,
+void TransformFromDomain::setDetectorMasks(DetectorItem* detector_item,
const GISASSimulation& simulation)
{
const IDetector* detector = simulation.getInstrument().getDetector();
if( (detector->detectorMask() && detector->detectorMask()->numberOfMasks()) ||
detector->regionOfInterest()) {
- detectorItem->createMaskContainer();
+ detector_item->createMaskContainer();
double scale(1.0);
- if(detectorItem->modelType() == Constants::SphericalDetectorType)
+ if(detector_item->modelType() == Constants::SphericalDetectorType)
scale = 1./Units::degree;
- setDetectorMasks(detectorItem->maskContainerItem(), *detector, scale);
+ setDetectorMasks(detector_item->maskContainerItem(), *detector, scale);
}
}
-void TransformFromDomain::setDetectorMasks(MaskContainerItem* containerItem,
+void TransformFromDomain::setDetectorMasks(MaskContainerItem* container_item,
const IDetector& detector, double scale)
{
auto detectorMask = detector.detectorMask();
@@ -432,7 +433,7 @@ void TransformFromDomain::setDetectorMasks(MaskContainerItem* containerItem,
ellipseItem->setItemValue(EllipseItem::P_YRADIUS, scale*ellipse->getRadiusY());
ellipseItem->setItemValue(EllipseItem::P_ANGLE, scale*ellipse->getTheta());
ellipseItem->setItemValue(MaskItem::P_MASK_VALUE, mask_value);
- containerItem->insertItem(0, ellipseItem);
+ container_item->insertItem(0, ellipseItem);
}
else if(const Rectangle* rectangle = dynamic_cast<const Rectangle*>(shape)) {
@@ -442,7 +443,7 @@ void TransformFromDomain::setDetectorMasks(MaskContainerItem* containerItem,
rectangleItem->setItemValue(RectangleItem::P_XUP, scale*rectangle->getXup());
rectangleItem->setItemValue(RectangleItem::P_YUP, scale*rectangle->getYup());
rectangleItem->setItemValue(MaskItem::P_MASK_VALUE, mask_value);
- containerItem->insertItem(0, rectangleItem);
+ container_item->insertItem(0, rectangleItem);
}
@@ -460,28 +461,28 @@ void TransformFromDomain::setDetectorMasks(MaskContainerItem* containerItem,
polygonItem->setItemValue(MaskItem::P_MASK_VALUE, mask_value);
polygonItem->setItemValue(PolygonItem::P_ISCLOSED, true);
- containerItem->insertItem(0, polygonItem);
+ container_item->insertItem(0, polygonItem);
}
else if(const VerticalLine* vline = dynamic_cast<const VerticalLine*>(shape)) {
VerticalLineItem* lineItem = new VerticalLineItem();
lineItem->setItemValue(VerticalLineItem::P_POSX, scale*vline->getXpos());
lineItem->setItemValue(MaskItem::P_MASK_VALUE, mask_value);
- containerItem->insertItem(0, lineItem);
+ container_item->insertItem(0, lineItem);
}
else if(const HorizontalLine* hline = dynamic_cast<const HorizontalLine*>(shape)) {
HorizontalLineItem* lineItem = new HorizontalLineItem();
lineItem->setItemValue(HorizontalLineItem::P_POSY, scale*hline->getYpos());
lineItem->setItemValue(MaskItem::P_MASK_VALUE, mask_value);
- containerItem->insertItem(0, lineItem);
+ container_item->insertItem(0, lineItem);
}
else if(const InfinitePlane* plane = dynamic_cast<const InfinitePlane*>(shape)) {
Q_UNUSED(plane);
MaskAllItem* planeItem = new MaskAllItem();
planeItem->setItemValue(MaskItem::P_MASK_VALUE, mask_value);
- containerItem->insertItem(-1, planeItem);
+ container_item->insertItem(-1, planeItem);
}
else {
@@ -496,17 +497,17 @@ void TransformFromDomain::setDetectorMasks(MaskContainerItem* containerItem,
roiItem->setItemValue(RectangleItem::P_YLOW, scale*detector.regionOfInterest()->getYlow());
roiItem->setItemValue(RectangleItem::P_XUP, scale*detector.regionOfInterest()->getXup());
roiItem->setItemValue(RectangleItem::P_YUP, scale*detector.regionOfInterest()->getYup());
- containerItem->insertItem(-1, roiItem);
+ container_item->insertItem(-1, roiItem);
}
}
-void TransformFromDomain::setItemFromSample(BeamDistributionItem* beamDistributionItem,
- const ParameterDistribution& parameterDistribution)
+void TransformFromDomain::setItemFromSample(BeamDistributionItem* beam_distribution_item,
+ const ParameterDistribution& parameter_distribution)
{
- Q_ASSERT(beamDistributionItem);
+ Q_ASSERT(beam_distribution_item);
- if (parameterDistribution.getMinValue() < parameterDistribution.getMaxValue()) {
+ if (parameter_distribution.getMinValue() < parameter_distribution.getMaxValue()) {
throw GUIHelpers::Error(
"TransformFromDomain::setItemFromSample(BeamDistributionItem* beamDistributionItem,"
"const ParameterDistribution& parameterDistribution) -> Error. ParameterDistribution "
@@ -514,12 +515,12 @@ void TransformFromDomain::setItemFromSample(BeamDistributionItem* beamDistributi
}
double unit_factor(1.0);
- if (beamDistributionItem->modelType() == Constants::BeamAzimuthalAngleType
- || beamDistributionItem->modelType() == Constants::BeamInclinationAngleType) {
+ if (beam_distribution_item->modelType() == Constants::BeamAzimuthalAngleType
+ || beam_distribution_item->modelType() == Constants::BeamInclinationAngleType) {
unit_factor = 1. / Units::degree;
}
QString group_name = BeamDistributionItem::P_DISTRIBUTION;
- setDistribution(beamDistributionItem, parameterDistribution, group_name, unit_factor);
+ setDistribution(beam_distribution_item, parameter_distribution, group_name, unit_factor);
}
void SetPDF1D(SessionItem* item, const IFTDistribution1D* ipdf, QString group_name)
@@ -708,40 +709,40 @@ void set2DLatticeParameters(SessionItem* item, const Lattice2D& lattice)
Units::rad2deg(lattice.rotationAngle()));
}
-void setDistribution(SessionItem* partDistrItem, ParameterDistribution par_distr,
+void setDistribution(SessionItem* part_distr_item, ParameterDistribution par_distr,
QString group_name, double factor)
{
const IDistribution1D* p_distribution = par_distr.getDistribution();
SessionItem* item = 0;
if (const DistributionGate* distr = dynamic_cast<const DistributionGate*>(p_distribution)) {
- item = partDistrItem->setGroupProperty(group_name, Constants::DistributionGateType);
+ item = part_distr_item->setGroupProperty(group_name, Constants::DistributionGateType);
item->setItemValue(DistributionGateItem::P_MIN, factor*distr->getMin());
item->setItemValue(DistributionGateItem::P_MAX, factor*distr->getMax());
} else if (const DistributionLorentz* distr
= dynamic_cast<const DistributionLorentz*>(p_distribution)) {
- item = partDistrItem->setGroupProperty(group_name, Constants::DistributionLorentzType);
+ item = part_distr_item->setGroupProperty(group_name, Constants::DistributionLorentzType);
item->setItemValue(DistributionLorentzItem::P_MEAN, factor*distr->getMean());
item->setItemValue(DistributionLorentzItem::P_HWHM, factor*distr->getHWHM());
} else if (const DistributionGaussian* distr
= dynamic_cast<const DistributionGaussian*>(p_distribution)) {
- item = partDistrItem->setGroupProperty(group_name, Constants::DistributionGaussianType);
+ item = part_distr_item->setGroupProperty(group_name, Constants::DistributionGaussianType);
item->setItemValue(DistributionGaussianItem::P_MEAN, factor*distr->getMean());
item->setItemValue(DistributionGaussianItem::P_STD_DEV, factor*distr->getStdDev());
} else if (const DistributionLogNormal* distr
= dynamic_cast<const DistributionLogNormal*>(p_distribution)) {
- item = partDistrItem->setGroupProperty(group_name, Constants::DistributionLogNormalType);
+ item = part_distr_item->setGroupProperty(group_name, Constants::DistributionLogNormalType);
item->setItemValue(DistributionLogNormalItem::P_MEDIAN, factor*distr->getMedian());
item->setItemValue(DistributionLogNormalItem::P_SCALE_PAR,
distr->getScalePar());
} else if (const DistributionCosine* distr
= dynamic_cast<const DistributionCosine*>(p_distribution)) {
- item = partDistrItem->setGroupProperty(group_name, Constants::DistributionCosineType);
+ item = part_distr_item->setGroupProperty(group_name, Constants::DistributionCosineType);
item->setItemValue(DistributionCosineItem::P_MEAN, factor*distr->getMean());
item->setItemValue(DistributionCosineItem::P_SIGMA, factor*distr->getSigma());
} else if (const DistributionTrapezoid* distr
= dynamic_cast<const DistributionTrapezoid*>(p_distribution)) {
- item = partDistrItem->setGroupProperty(group_name, Constants::DistributionTrapezoidType);
+ item = part_distr_item->setGroupProperty(group_name, Constants::DistributionTrapezoidType);
item->setItemValue(DistributionTrapezoidItem::P_CENTER, factor*distr->getMean());
item->setItemValue(DistributionTrapezoidItem::P_LEFTWIDTH, factor*distr->getLeftWidth());
item->setItemValue(DistributionTrapezoidItem::P_MIDDLEWIDTH,
diff --git a/GUI/coregui/Models/TransformFromDomain.h b/GUI/coregui/Models/TransformFromDomain.h
index ff8f675cde4..c0b355e9ee8 100644
--- a/GUI/coregui/Models/TransformFromDomain.h
+++ b/GUI/coregui/Models/TransformFromDomain.h
@@ -45,55 +45,58 @@ class InstrumentItem;
namespace TransformFromDomain
{
-BA_CORE_API_ void setItemFromSample(SessionItem *item,
- const FormFactorAnisoPyramid *sample);
+BA_CORE_API_ void setItemFromSample(SessionItem* item,
+ const FormFactorAnisoPyramid* sample);
-BA_CORE_API_ void setItemFromSample(SessionItem *item,
- const InterferenceFunctionRadialParaCrystal *sample);
+BA_CORE_API_ void setItemFromSample(SessionItem* item,
+ const InterferenceFunctionRadialParaCrystal* sample);
-BA_CORE_API_ void setItemFromSample(SessionItem *item,
- const InterferenceFunction2DParaCrystal *sample);
+BA_CORE_API_ void setItemFromSample(SessionItem* item,
+ const InterferenceFunction2DParaCrystal* sample);
-BA_CORE_API_ void setItemFromSample(SessionItem *item,
- const InterferenceFunction1DLattice *sample);
+BA_CORE_API_ void setItemFromSample(SessionItem* item,
+ const InterferenceFunction1DLattice* sample);
-BA_CORE_API_ void setItemFromSample(SessionItem *item,
- const InterferenceFunction2DLattice *sample);
+BA_CORE_API_ void setItemFromSample(SessionItem* item,
+ const InterferenceFunction2DLattice* sample);
-BA_CORE_API_ void setItemFromSample(SessionItem *layerItem, const Layer *layer,
- const LayerInterface *top_interface);
+BA_CORE_API_ void setItemFromSample(SessionItem* layer_item, const Layer* layer,
+ const LayerInterface* top_interface);
-BA_CORE_API_ void setItemFromSample(SessionItem *item,
- const LayerRoughness *sample);
+BA_CORE_API_ void setItemFromSample(SessionItem* item,
+ const LayerRoughness* sample);
-BA_CORE_API_ void setItemFromSample(SessionItem *item,
- const ParticleDistribution *sample);
+BA_CORE_API_ void setItemFromSample(SessionItem* item,
+ const ParticleDistribution* sample);
-BA_CORE_API_ bool isValidRoughness(const LayerRoughness *roughness);
+BA_CORE_API_ bool isValidRoughness(const LayerRoughness* roughness);
-BA_CORE_API_ void setItemFromSample(BeamItem *beamItem,
- const GISASSimulation &simulation);
+BA_CORE_API_ void setItemFromSample(BeamItem* beam_item,
+ const GISASSimulation& simulation);
-BA_CORE_API_ void setInstrumentDetectorFromSample(InstrumentItem *detectorItem,
- const GISASSimulation &simulation);
+BA_CORE_API_ void setInstrumentDetectorFromSample(InstrumentItem* detector_item,
+ const GISASSimulation& simulation);
-BA_CORE_API_ void setItemFromSample(SphericalDetectorItem *detectorItem,
+BA_CORE_API_ void setItemFromSample(SphericalDetectorItem* detector_item,
const SphericalDetector &detector);
-BA_CORE_API_ void setItemFromSample(RectangularDetectorItem *detectorItem,
+BA_CORE_API_ void setItemFromSample(RectangularDetectorItem* detector_item,
const RectangularDetector &detector);
-BA_CORE_API_ void setDetectorMasks(DetectorItem *detectorItem,
- const GISASSimulation &simulation);
+BA_CORE_API_ void setDetectorMasks(DetectorItem* detector_item,
+ const GISASSimulation& simulation);
-BA_CORE_API_ void setDetectorMasks(MaskContainerItem *containerItem,
- const IDetector &detector, double scale);
+BA_CORE_API_ void setDetectorMasks(MaskContainerItem* container_item,
+ const IDetector& detector, double scale);
-BA_CORE_API_ void setItemFromSample(BeamDistributionItem *beamDistributionItem,
- const ParameterDistribution ¶meterDistribution);
+BA_CORE_API_ void setBackground(InstrumentItem* instrument_item,
+ const GISASSimulation& simulation);
-BA_CORE_API_ void setItemFromSample(BeamDistributionItem *beamDistributionItem,
- const ParameterDistribution ¶meterDistribution);
+BA_CORE_API_ void setItemFromSample(BeamDistributionItem* beam_distribution_item,
+ const ParameterDistribution& parameter_distribution);
+
+BA_CORE_API_ void setItemFromSample(BeamDistributionItem* beam_distribution_item,
+ const ParameterDistribution& parameter_distribution);
}
diff --git a/Tests/Functional/Core/CoreStandardTest/CMakeLists.txt b/Tests/Functional/Core/CoreStandardTest/CMakeLists.txt
index a3380a9a5c1..f9f247a954e 100644
--- a/Tests/Functional/Core/CoreStandardTest/CMakeLists.txt
+++ b/Tests/Functional/Core/CoreStandardTest/CMakeLists.txt
@@ -16,6 +16,7 @@ set(test_cases
BoxesWithSpecular
BoxStackComposition
CenteredSquareLattice
+ ConstantBackground
CoreShellBoxRotateZandY
CoreShellParticle
CosineRipple
diff --git a/Tests/Functional/GUI/GUIStandardTest/CMakeLists.txt b/Tests/Functional/GUI/GUIStandardTest/CMakeLists.txt
index 8b533ce4389..7a27b81c3f3 100644
--- a/Tests/Functional/GUI/GUIStandardTest/CMakeLists.txt
+++ b/Tests/Functional/GUI/GUIStandardTest/CMakeLists.txt
@@ -15,6 +15,7 @@ set(test_cases
BoxesWithSpecular
BoxStackComposition
CenteredSquareLattice
+ ConstantBackground
CoreShellBoxRotateZandY
CoreShellParticle
CosineRipple
diff --git a/Tests/Functional/Python/PyStandard/CMakeLists.txt b/Tests/Functional/Python/PyStandard/CMakeLists.txt
index fc002a4f776..282ece4087f 100644
--- a/Tests/Functional/Python/PyStandard/CMakeLists.txt
+++ b/Tests/Functional/Python/PyStandard/CMakeLists.txt
@@ -19,6 +19,7 @@ set(test_cases
BoxesWithSpecular
BoxStackComposition
CenteredSquareLattice
+ ConstantBackground
CoreShellBoxRotateZandY
CoreShellParticle
CosineRipple
diff --git a/Tests/Functional/TestMachinery/StandardTestCatalogue.cpp b/Tests/Functional/TestMachinery/StandardTestCatalogue.cpp
index 89b0b80d5c9..02762ef2e82 100644
--- a/Tests/Functional/TestMachinery/StandardTestCatalogue.cpp
+++ b/Tests/Functional/TestMachinery/StandardTestCatalogue.cpp
@@ -363,6 +363,14 @@ StandardTestCatalogue::StandardTestCatalogue()
"SlicedCompositionBuilder",
1e-10);
+ // Simulations with background
+
+ add("ConstantBackground",
+ "Constant background is added to the simulation",
+ "ConstantBackground",
+ "CylindersInBABuilder",
+ 1e-10);
+
// Specular simulations
add("HomogeneousTiNiSample",
diff --git a/Tests/ReferenceData/StandardSuite/ConstantBackground.int.gz b/Tests/ReferenceData/StandardSuite/ConstantBackground.int.gz
new file mode 100644
index 0000000000000000000000000000000000000000..1d085c6ef07a68719dc63b4a843fa5b7354e2795
GIT binary patch
literal 2128
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
H#=rmoxIYNL
literal 0
HcmV?d00001
--
GitLab