BornAgain  1.18.0
Simulate and fit neutron and x-ray scattering at grazing incidence
SizeDistributionModelsBuilder.cpp
Go to the documentation of this file.
1 // ************************************************************************** //
2 //
3 // BornAgain: simulate and fit scattering at grazing incidence
4 //
5 //! @file Sample/StandardSamples/SizeDistributionModelsBuilder.cpp
6 //! @brief Implements class ParticlesInSSCABuilder.
7 //!
8 //! @homepage http://www.bornagainproject.org
9 //! @license GNU General Public License v3 or higher (see COPYING)
10 //! @copyright Forschungszentrum Jülich GmbH 2018
11 //! @authors Scientific Computing Group at MLZ (see CITATION, AUTHORS)
12 //
13 // ************************************************************************** //
14 
15 #include "Sample/StandardSamples/SizeDistributionModelsBuilder.h"
16 #include "Base/Const/Units.h"
17 #include "Param/Distrib/Distributions.h"
18 #include "Param/Varia/ParameterPattern.h"
19 #include "Sample/Aggregate/InterferenceFunctionRadialParaCrystal.h"
20 #include "Sample/Aggregate/ParticleLayout.h"
21 #include "Sample/HardParticle/FormFactorCylinder.h"
22 #include "Sample/Multilayer/Layer.h"
23 #include "Sample/Multilayer/MultiLayer.h"
24 #include "Sample/Particle/Particle.h"
25 #include "Sample/Particle/ParticleDistribution.h"
26 #include "Sample/StandardSamples/ReferenceMaterials.h"
27 
28 MultiLayer* SizeDistributionDAModelBuilder::buildSample() const
29 {
30  // cylindrical particle 1
31  double radius1(5 * Units::nanometer);
32  double height1 = radius1;
33  FormFactorCylinder cylinder_ff1(radius1, height1);
34  Particle cylinder1(refMat::Particle, cylinder_ff1);
35 
36  // cylindrical particle 2
37  double radius2(8 * Units::nanometer);
38  double height2(radius2);
39  FormFactorCylinder cylinder_ff2(radius2, height2);
40  Particle cylinder2(refMat::Particle, cylinder_ff2);
41 
42  // interference function
43  InterferenceFunctionRadialParaCrystal interference(18.0 * Units::nanometer,
44  1e3 * Units::nanometer);
45  FTDistribution1DGauss pdf(3 * Units::nanometer);
46  interference.setProbabilityDistribution(pdf);
47 
48  // assembling the sample
49  ParticleLayout particle_layout;
50  particle_layout.addParticle(cylinder1, 0.8);
51  particle_layout.addParticle(cylinder2, 0.2);
52  particle_layout.setInterferenceFunction(interference);
53 
54  Layer vacuum_layer(refMat::Vacuum);
55  vacuum_layer.addLayout(particle_layout);
56  Layer substrate_layer(refMat::Substrate);
57 
58  MultiLayer* multi_layer = new MultiLayer();
59  multi_layer->addLayer(vacuum_layer);
60  multi_layer->addLayer(substrate_layer);
61  return multi_layer;
62 }
63 
64 // ----------------------------------------------------------------------------
65 
66 MultiLayer* SizeDistributionLMAModelBuilder::buildSample() const
67 {
68  // cylindrical particle 1
69  double radius1(5 * Units::nanometer);
70  double height1 = radius1;
71  FormFactorCylinder cylinder_ff1(radius1, height1);
72  Particle cylinder1(refMat::Particle, cylinder_ff1);
73 
74  // cylindrical particle 2
75  double radius2(8 * Units::nanometer);
76  double height2(radius2);
77  FormFactorCylinder cylinder_ff2(radius2, height2);
78  Particle cylinder2(refMat::Particle, cylinder_ff2);
79 
80  // interference function1
81  InterferenceFunctionRadialParaCrystal interference1(16.8 * Units::nanometer,
82  1e3 * Units::nanometer);
83  FTDistribution1DGauss pdf(3 * Units::nanometer);
84  interference1.setProbabilityDistribution(pdf);
85 
86  // interference function2
87  InterferenceFunctionRadialParaCrystal interference2(22.8 * Units::nanometer,
88  1e3 * Units::nanometer);
89  interference2.setProbabilityDistribution(pdf);
90 
91  // assembling the sample
92  ParticleLayout particle_layout1;
93  particle_layout1.addParticle(cylinder1, 0.8);
94  particle_layout1.setInterferenceFunction(interference1);
95 
96  ParticleLayout particle_layout2;
97  particle_layout2.addParticle(cylinder2, 0.2);
98  particle_layout2.setInterferenceFunction(interference2);
99 
100  Layer vacuum_layer(refMat::Vacuum);
101  vacuum_layer.addLayout(particle_layout1);
102  vacuum_layer.addLayout(particle_layout2);
103  Layer substrate_layer(refMat::Substrate);
104 
105  MultiLayer* multi_layer = new MultiLayer();
106  multi_layer->addLayer(vacuum_layer);
107  multi_layer->addLayer(substrate_layer);
108  return multi_layer;
109 }
110 
111 // ----------------------------------------------------------------------------
112 
113 MultiLayer* SizeDistributionSSCAModelBuilder::buildSample() const
114 {
115  // cylindrical particle 1
116  double radius1(5 * Units::nanometer);
117  double height1 = radius1;
118  FormFactorCylinder cylinder_ff1(radius1, height1);
119  Particle cylinder1(refMat::Particle, cylinder_ff1);
120 
121  // cylindrical particle 2
122  double radius2(8 * Units::nanometer);
123  double height2(radius2);
124  FormFactorCylinder cylinder_ff2(radius2, height2);
125  Particle cylinder2(refMat::Particle, cylinder_ff2);
126 
127  // interference function
128  InterferenceFunctionRadialParaCrystal interference(18.0 * Units::nanometer,
129  1e3 * Units::nanometer);
130  FTDistribution1DGauss pdf(3 * Units::nanometer);
131  interference.setProbabilityDistribution(pdf);
132  interference.setKappa(1.0);
133 
134  // assembling the sample
135  ParticleLayout particle_layout;
136  particle_layout.addParticle(cylinder1, 0.8);
137  particle_layout.addParticle(cylinder2, 0.2);
138  particle_layout.setInterferenceFunction(interference);
139 
140  Layer vacuum_layer(refMat::Vacuum);
141  vacuum_layer.addLayout(particle_layout);
142  Layer substrate_layer(refMat::Substrate);
143 
144  MultiLayer* multi_layer = new MultiLayer();
145  multi_layer->addLayer(vacuum_layer);
146  multi_layer->addLayer(substrate_layer);
147  return multi_layer;
148 }
149 
150 // ----------------------------------------------------------------------------
151 
152 MultiLayer* CylindersInSSCABuilder::buildSample() const
153 {
154  Layer vacuum_layer(refMat::Vacuum);
155 
156  InterferenceFunctionRadialParaCrystal interference_function(15.0 * Units::nanometer,
157  1e3 * Units::nanometer);
158  FTDistribution1DGauss pdf(5 * Units::nanometer);
159  interference_function.setProbabilityDistribution(pdf);
160  interference_function.setKappa(4.02698);
161  ParticleLayout particle_layout;
162 
163  FormFactorCylinder ff_cylinder(5.0 * Units::nanometer, 5.0 * Units::nanometer);
164  Particle particle_prototype(refMat::Particle, ff_cylinder);
165 
166  DistributionGaussian gauss(5.0 * Units::nanometer, 1.25 * Units::nanometer);
167  ParameterPattern pattern_radius;
168  pattern_radius.add("Particle").add("Cylinder").add("Radius");
169  ParameterDistribution par_distr(pattern_radius.toStdString(), gauss, 30, 3.0);
170  ParameterPattern pattern_height;
171  pattern_height.add("Particle").add("Cylinder").add("Height");
172  par_distr.linkParameter(pattern_height.toStdString());
173  ParticleDistribution particle_collection(particle_prototype, par_distr);
174  particle_layout.addParticle(particle_collection);
175 
176  particle_layout.setInterferenceFunction(interference_function);
177 
178  vacuum_layer.addLayout(particle_layout);
179 
180  MultiLayer* multi_layer = new MultiLayer();
181  multi_layer->addLayer(vacuum_layer);
182  return multi_layer;
183 }
Distributions.h
Defines classes representing one-dimensional distributions.
FormFactorCylinder.h
Defines class FormFactorCylinder.
InterferenceFunctionRadialParaCrystal.h
Defines class InterferenceFunctionRadialParaCrystal.
Layer.h
Defines class Layer.
MultiLayer.h
Defines class MultiLayer.
ParameterPattern.h
Defines class ParameterPattern.
ParticleDistribution.h
Defines class ParticleDistribution.
ParticleLayout.h
Defines class ParticleLayout.
Particle.h
Defines class Particle.
ReferenceMaterials.h
Defines materials in namespace refMat.
SizeDistributionModelsBuilder.h
Defines various sample builder classes to test DA, LMA, SSCA approximations.
Units.h
Defines some unit conversion factors and other constants in namespace Units.
DistributionGaussian
Gaussian distribution with standard deviation std_dev.
Definition: Distributions.h:153
FTDistribution1DGauss
Gaussian IFTDistribution1D; its Fourier transform evaluate(q) is a Gaussian starting at evaluate(0)=1...
Definition: FTDistributions1D.h:75
FormFactorCylinder
A circular cylinder.
Definition: FormFactorCylinder.h:24
InterferenceFunctionRadialParaCrystal
Interference function of radial paracrystal.
Definition: InterferenceFunctionRadialParaCrystal.h:27
InterferenceFunctionRadialParaCrystal::setKappa
void setKappa(double kappa)
Sets size spacing coupling parameter of the Size Spacing Correlation Approximation.
Definition: InterferenceFunctionRadialParaCrystal.cpp:50
InterferenceFunctionRadialParaCrystal::setProbabilityDistribution
void setProbabilityDistribution(const IFTDistribution1D &pdf)
Sets one-dimensional probability distribution.
Definition: InterferenceFunctionRadialParaCrystal.cpp:81
Layer
A layer, with thickness (in nanometer) and material.
Definition: Layer.h:28
Layer::addLayout
void addLayout(const ILayout &decoration)
Definition: Layer.cpp:57
MultiLayer
Our sample model: a stack of layers one below the other.
Definition: MultiLayer.h:42
MultiLayer::addLayer
void addLayer(const Layer &layer)
Adds object to multilayer.
Definition: MultiLayer.cpp:54
ParameterDistribution
A parametric distribution function, for use with any model parameter.
Definition: ParameterDistribution.h:29
ParameterDistribution::linkParameter
ParameterDistribution & linkParameter(std::string par_name)
Definition: ParameterDistribution.cpp:87
ParameterPattern
Helper class for constructing parameter patterns.
Definition: ParameterPattern.h:24
ParameterPattern::toStdString
std::string toStdString() const
Definition: ParameterPattern.h:32
ParameterPattern::add
ParameterPattern & add(std::string object_type)
Definition: ParameterPattern.cpp:23
ParticleDistribution
A particle type that is a parametric distribution of IParticle's.
Definition: ParticleDistribution.h:28
ParticleLayout
Decorator class that adds particles to ISample objects.
Definition: ParticleLayout.h:30
ParticleLayout::setInterferenceFunction
void setInterferenceFunction(const IInterferenceFunction &interference_function)
Adds interference functions.
Definition: ParticleLayout.cpp:121
ParticleLayout::addParticle
void addParticle(const IAbstractParticle &particle, double abundance=-1.0, const kvector_t position={}, const IRotation &rotation=IdentityRotation())
Adds particle to the layout with abundance, position and the rotation defined.
Definition: ParticleLayout.cpp:76
Particle
A particle with a form factor and refractive index.
Definition: Particle.h:26
Units::gauss
static constexpr double gauss
Definition: Units.h:60
Units::nanometer
static constexpr double nanometer
Definition: Units.h:24
refMat::Vacuum
static const Material Vacuum
Definition: ReferenceMaterials.h:25
refMat::Particle
static const Material Particle
Definition: ReferenceMaterials.h:27
refMat::Substrate
static const Material Substrate
Definition: ReferenceMaterials.h:26