BornAgain  1.18.0
Simulate and fit neutron and x-ray scattering at grazing incidence
ParaCrystalBuilder.cpp
Go to the documentation of this file.
1 // ************************************************************************** //
2 //
3 // BornAgain: simulate and fit scattering at grazing incidence
4 //
5 //! @file Sample/StandardSamples/ParaCrystalBuilder.cpp
6 //! @brief Implements class ParaCrystalBuilder.
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/ParaCrystalBuilder.h"
16 #include "Base/Const/Units.h"
17 #include "Base/Utils/Assert.h"
18 #include "Sample/Aggregate/InterferenceFunction2DParaCrystal.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/SampleBuilderEngine/SampleComponents.h"
26 #include "Sample/StandardSamples/ReferenceMaterials.h"
27 
28 MultiLayer* RadialParaCrystalBuilder::buildSample() const
29 {
30  const double m_corr_peak_distance(20.0 * Units::nanometer);
31  const double m_corr_width(7 * Units::nanometer);
32  const double m_corr_length(1e3 * Units::nanometer);
33  const double m_cylinder_height(5 * Units::nanometer);
34  const double m_cylinder_radius(5 * Units::nanometer);
35 
36  Layer vacuum_layer(refMat::Vacuum);
37  Layer substrate_layer(refMat::Substrate);
38 
39  InterferenceFunctionRadialParaCrystal interference_function(m_corr_peak_distance,
40  m_corr_length);
41  FTDistribution1DGauss pdf(m_corr_width);
42  interference_function.setProbabilityDistribution(pdf);
43  FormFactorCylinder ff_cylinder(m_cylinder_radius, m_cylinder_height);
44 
45  Particle particle(refMat::Particle, ff_cylinder);
46  ParticleLayout particle_layout(particle);
47  particle_layout.setInterferenceFunction(interference_function);
48 
49  vacuum_layer.addLayout(particle_layout);
50 
51  MultiLayer* multi_layer = new MultiLayer();
52  multi_layer->addLayer(vacuum_layer);
53  multi_layer->addLayer(substrate_layer);
54  return multi_layer;
55 }
56 
57 // -----------------------------------------------------------------------------
58 // Basic2DParaCrystalBuilder
59 // -----------------------------------------------------------------------------
60 
61 Basic2DParaCrystalBuilder::Basic2DParaCrystalBuilder()
62  : m_pdf1(new FTDistribution2DCauchy(0.1 * Units::nanometer, 0.2 * Units::nanometer, 0)),
63  m_pdf2(new FTDistribution2DCauchy(0.3 * Units::nanometer, 0.4 * Units::nanometer, 0))
64 {
65 }
66 
67 Basic2DParaCrystalBuilder::~Basic2DParaCrystalBuilder() = default;
68 
69 MultiLayer* Basic2DParaCrystalBuilder::buildSample() const
70 {
71  Layer vacuum_layer(refMat::Vacuum);
72  Layer substrate_layer(refMat::Substrate);
73 
74  InterferenceFunction2DParaCrystal interference_function(
75  10.0 * Units::nanometer, 20.0 * Units::nanometer, 30.0 * Units::degree,
76  45.0 * Units::degree, 1000.0 * Units::nanometer);
77 
78  interference_function.setDomainSizes(20.0 * Units::micrometer, 40.0 * Units::micrometer);
79 
80  interference_function.setProbabilityDistributions(*m_pdf1, *m_pdf2);
81 
82  FormFactorCylinder ff_cylinder(5.0 * Units::nanometer, 5.0 * Units::nanometer);
83 
84  Particle particle(refMat::Particle, ff_cylinder);
85  ParticleLayout particle_layout(particle);
86  particle_layout.setInterferenceFunction(interference_function);
87 
88  vacuum_layer.addLayout(particle_layout);
89 
90  MultiLayer* multi_layer = new MultiLayer();
91  multi_layer->addLayer(vacuum_layer);
92  multi_layer->addLayer(substrate_layer);
93  return multi_layer;
94 }
95 
96 MultiLayer* Basic2DParaCrystalBuilder::createSampleByIndex(size_t index)
97 {
98  ASSERT(index < FTDistribution2DComponents().size());
99 
100  auto names = FTDistribution2DComponents().keys();
101  m_pdf2.reset(FTDistribution2DComponents().getItem(names.at(index))->clone());
102 
103  setName(names.at(index));
104 
105  return buildSample();
106 }
107 
108 // -----------------------------------------------------------------------------
109 // HexParaCrystalBuilder
110 // -----------------------------------------------------------------------------
111 
112 MultiLayer* HexParaCrystalBuilder::buildSample() const
113 {
114  const double m_peak_distance(20.0 * Units::nanometer);
115  const double m_corr_length(0.0);
116  const double m_domain_size_1(20.0 * Units::micrometer);
117  const double m_domain_size_2(20.0 * Units::micrometer);
118  const double m_cylinder_height(5 * Units::nanometer);
119  const double m_cylinder_radius(5 * Units::nanometer);
120 
121  Layer vacuum_layer(refMat::Vacuum);
122  Layer substrate_layer(refMat::Substrate);
123 
124  std::unique_ptr<InterferenceFunction2DParaCrystal> P_interference_function{
125  InterferenceFunction2DParaCrystal::createHexagonal(m_peak_distance, m_corr_length,
126  m_domain_size_1, m_domain_size_2)};
127  FTDistribution2DCauchy pdf(1.0 * Units::nanometer, 1.0 * Units::nanometer, 0);
128  P_interference_function->setProbabilityDistributions(pdf, pdf);
129 
130  FormFactorCylinder ff_cylinder(m_cylinder_radius, m_cylinder_height);
131  Particle cylinder(refMat::Particle, ff_cylinder);
132 
133  ParticleLayout particle_layout(cylinder);
134  particle_layout.setInterferenceFunction(*P_interference_function);
135 
136  vacuum_layer.addLayout(particle_layout);
137 
138  MultiLayer* multi_layer = new MultiLayer();
139  multi_layer->addLayer(vacuum_layer);
140  multi_layer->addLayer(substrate_layer);
141  return multi_layer;
142 }
143 
144 // -----------------------------------------------------------------------------
145 // RectParaCrystalBuilder
146 // -----------------------------------------------------------------------------
147 
148 MultiLayer* RectParaCrystalBuilder::buildSample() const
149 {
150  Layer vacuum_layer(refMat::Vacuum);
151  Layer substrate_layer(refMat::Substrate);
152 
153  std::unique_ptr<InterferenceFunction2DParaCrystal> P_interference_function{
154  InterferenceFunction2DParaCrystal::createSquare(10 * Units::nanometer, 0 * Units::nanometer,
155  0, 0)};
156 
157  P_interference_function->setDomainSizes(20.0 * Units::micrometer, 20.0 * Units::micrometer);
158  FTDistribution2DCauchy pdf1(0.5 * Units::nanometer, 2.0 * Units::nanometer, 0);
159  FTDistribution2DCauchy pdf2(0.5 * Units::nanometer, 2.0 * Units::nanometer, 0);
160  P_interference_function->setProbabilityDistributions(pdf1, pdf2);
161 
162  FormFactorCylinder ff_cylinder(5.0 * Units::nanometer, 5.0 * Units::nanometer);
163 
164  Particle particle(refMat::Particle, ff_cylinder);
165  ParticleLayout particle_layout(particle);
166  particle_layout.setInterferenceFunction(*P_interference_function);
167 
168  vacuum_layer.addLayout(particle_layout);
169 
170  MultiLayer* multi_layer = new MultiLayer();
171  multi_layer->addLayer(vacuum_layer);
172  multi_layer->addLayer(substrate_layer);
173  return multi_layer;
174 }
Assert.h
Defines the macro ASSERT.
FormFactorCylinder.h
Defines class FormFactorCylinder.
InterferenceFunction2DParaCrystal.h
Defines class InterferenceFunction2DParaCrystal.
InterferenceFunctionRadialParaCrystal.h
Defines class InterferenceFunctionRadialParaCrystal.
Layer.h
Defines class Layer.
MultiLayer.h
Defines class MultiLayer.
ParaCrystalBuilder.h
Defines classes of ParaCrystalBuilder family.
ParticleLayout.h
Defines class ParticleLayout.
Particle.h
Defines class Particle.
ReferenceMaterials.h
Defines materials in namespace refMat.
SampleComponents.h
Defines sample components for complex sample builders.
Units.h
Defines some unit conversion factors and other constants in namespace Units.
FTDistribution1DGauss
Gaussian IFTDistribution1D; its Fourier transform evaluate(q) is a Gaussian starting at evaluate(0)=1...
Definition: FTDistributions1D.h:75
FTDistribution2DCauchy
Two-dimensional Cauchy distribution in Fourier space; corresponds to a normalized exp(-r) in real spa...
Definition: FTDistributions2D.h:63
FTDistribution2DComponents
Predefined Fourier transformed distributions for functional tests.
Definition: SampleComponents.h:25
FormFactorCylinder
A circular cylinder.
Definition: FormFactorCylinder.h:24
InterferenceFunction2DParaCrystal
Interference function of a 2D paracrystal.
Definition: InterferenceFunction2DParaCrystal.h:30
InterferenceFunction2DParaCrystal::createHexagonal
static InterferenceFunction2DParaCrystal * createHexagonal(double lattice_length, double damping_length, double domain_size_1, double domain_size_2)
Creates hexagonal lattice.
Definition: InterferenceFunction2DParaCrystal.cpp:137
InterferenceFunction2DParaCrystal::createSquare
static InterferenceFunction2DParaCrystal * createSquare(double lattice_length, double damping_length, double domain_size_1, double domain_size_2)
Creates square lattice.
Definition: InterferenceFunction2DParaCrystal.cpp:121
InterferenceFunction2DParaCrystal::setDomainSizes
void setDomainSizes(double size_1, double size_2)
Sets the sizes of coherence domains.
Definition: InterferenceFunction2DParaCrystal.cpp:150
InterferenceFunctionRadialParaCrystal
Interference function of radial paracrystal.
Definition: InterferenceFunctionRadialParaCrystal.h:27
Layer
A layer, with thickness (in nanometer) and material.
Definition: Layer.h:28
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
ParticleLayout
Decorator class that adds particles to ISample objects.
Definition: ParticleLayout.h:30
Particle
A particle with a form factor and refractive index.
Definition: Particle.h:26
Units
Constants and functions for physical unit conversions.
Definition: Units.h:21