BornAgain  1.18.0
Simulate and fit neutron and x-ray scattering at grazing incidence
TwoDimLatticeBuilder.cpp
Go to the documentation of this file.
1 // ************************************************************************** //
2 //
3 // BornAgain: simulate and fit scattering at grazing incidence
4 //
5 //! @file Sample/StandardSamples/TwoDimLatticeBuilder.cpp
6 //! @brief Implements class IsGISAXS06Builder.
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/TwoDimLatticeBuilder.h"
16 #include "Base/Const/Units.h"
17 #include "Sample/Aggregate/InterferenceFunction2DLattice.h"
18 #include "Sample/Aggregate/InterferenceFunction2DSuperLattice.h"
19 #include "Sample/Aggregate/InterferenceFunctionFinite2DLattice.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/ParticleComposition.h"
26 #include "Sample/StandardSamples/ReferenceMaterials.h"
27 
28 MultiLayer* Basic2DLatticeBuilder::buildSample() const
29 {
30  Layer vacuum_layer(refMat::Vacuum);
31  Layer substrate_layer(refMat::Substrate);
32 
33  std::unique_ptr<InterferenceFunction2DLattice> P_interference_function(
34  new InterferenceFunction2DLattice(5.0 * Units::nanometer, 10.0 * Units::nanometer,
35  30.0 * Units::deg, 10.0 * Units::deg));
36 
37  FTDecayFunction2DCauchy pdf(300.0 * Units::nanometer / 2.0 / M_PI,
38  100.0 * Units::nanometer / 2.0 / M_PI, 0);
39  P_interference_function->setDecayFunction(pdf);
40 
41  // particles
42  ParticleLayout particle_layout;
43  FormFactorCylinder ff_cyl(5.0 * Units::nanometer, 5.0 * Units::nanometer);
44  Particle particle(refMat::Particle, ff_cyl);
45  particle_layout.addParticle(particle, 1.0);
46 
47  particle_layout.setInterferenceFunction(*P_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 // lattice #1:
59 // -----------------------------------------------------------------------------
60 MultiLayer* SquareLatticeBuilder::buildSample() const
61 {
62  Layer vacuum_layer(refMat::Vacuum);
63  Layer substrate_layer(refMat::Substrate);
64 
65  std::unique_ptr<InterferenceFunction2DLattice> P_interference_function{
66  InterferenceFunction2DLattice::createSquare(10.0 * Units::nanometer, 0)};
67  FTDecayFunction2DCauchy pdf(300.0 * Units::nanometer / 2.0 / M_PI,
68  100.0 * Units::nanometer / 2.0 / M_PI, 0);
69  P_interference_function->setDecayFunction(pdf);
70 
71  // particles
72  ParticleLayout particle_layout;
73  FormFactorCylinder ff_cyl(5.0 * Units::nanometer, 5.0 * Units::nanometer);
74  Particle particle(refMat::Particle, ff_cyl);
75  particle_layout.addParticle(particle, 1.0);
76 
77  particle_layout.setInterferenceFunction(*P_interference_function);
78 
79  vacuum_layer.addLayout(particle_layout);
80 
81  MultiLayer* multi_layer = new MultiLayer();
82  multi_layer->addLayer(vacuum_layer);
83  multi_layer->addLayer(substrate_layer);
84  return multi_layer;
85 }
86 
87 // -----------------------------------------------------------------------------
88 // lattice #2: centered
89 // -----------------------------------------------------------------------------
90 MultiLayer* CenteredSquareLatticeBuilder::buildSample() const
91 {
92  Layer vacuum_layer(refMat::Vacuum);
93  Layer substrate_layer(refMat::Substrate);
94 
95  InterferenceFunction2DLattice interference_function(10.0 * Units::nanometer,
96  10.0 * Units::nanometer, M_PI / 2.0, 0);
97  FTDecayFunction2DCauchy pdf(300.0 * Units::nanometer / 2.0 / M_PI,
98  100.0 * Units::nanometer / 2.0 / M_PI, 0);
99  interference_function.setDecayFunction(pdf);
100 
101  FormFactorCylinder ff_cyl(5.0 * Units::nanometer, 5.0 * Units::nanometer);
102  Particle cylinder(refMat::Particle, ff_cyl);
103  std::vector<kvector_t> positions;
104  kvector_t position_1(0.0, 0.0, 0.0);
105  kvector_t position_2(5.0 * Units::nanometer, -5.0 * Units::nanometer, 0.0);
106  positions.push_back(position_1);
107  positions.push_back(position_2);
108  ParticleComposition basis;
109  basis.addParticles(cylinder, positions);
110 
111  ParticleLayout particle_layout;
112  particle_layout.addParticle(basis);
113  particle_layout.setInterferenceFunction(interference_function);
114  vacuum_layer.addLayout(particle_layout);
115 
116  MultiLayer* multi_layer = new MultiLayer();
117  multi_layer->addLayer(vacuum_layer);
118  multi_layer->addLayer(substrate_layer);
119  return multi_layer;
120 }
121 
122 // -----------------------------------------------------------------------------
123 // lattice #3: rotated
124 // -----------------------------------------------------------------------------
125 MultiLayer* RotatedSquareLatticeBuilder::buildSample() const
126 {
127  Layer vacuum_layer(refMat::Vacuum);
128  Layer substrate_layer(refMat::Substrate);
129 
130  std::unique_ptr<InterferenceFunction2DLattice> P_interference_function{
131  InterferenceFunction2DLattice::createSquare(10.0 * Units::nanometer, 30.0 * Units::degree)};
132  FTDecayFunction2DCauchy pdf(300.0 * Units::nanometer / 2.0 / M_PI,
133  100.0 * Units::nanometer / 2.0 / M_PI, 30.0 * Units::degree);
134  P_interference_function->setDecayFunction(pdf);
135 
136  ParticleLayout particle_layout;
137  // particle
138  FormFactorCylinder ff_cyl(5.0 * Units::nanometer, 5.0 * Units::nanometer);
139  kvector_t position(0.0, 0.0, 0.0);
140  Particle p(refMat::Particle, ff_cyl);
141  p.setPosition(position);
142  particle_layout.addParticle(p);
143  particle_layout.setInterferenceFunction(*P_interference_function);
144 
145  vacuum_layer.addLayout(particle_layout);
146 
147  MultiLayer* multi_layer = new MultiLayer();
148  multi_layer->addLayer(vacuum_layer);
149  multi_layer->addLayer(substrate_layer);
150  return multi_layer;
151 }
152 
153 // -----------------------------------------------------------------------------
154 // lattice #4: finite square
155 // -----------------------------------------------------------------------------
156 MultiLayer* FiniteSquareLatticeBuilder::buildSample() const
157 {
158  Layer vacuum_layer(refMat::Vacuum);
159  Layer substrate_layer(refMat::Substrate);
160 
161  std::unique_ptr<InterferenceFunctionFinite2DLattice> P_interference_function{
162  InterferenceFunctionFinite2DLattice::createSquare(10.0 * Units::nanometer, 0.0, 40, 40)};
163  P_interference_function->setPositionVariance(1.0);
164 
165  // particles
166  ParticleLayout particle_layout;
167  FormFactorCylinder ff_cyl(5.0 * Units::nanometer, 5.0 * Units::nanometer);
168  Particle particle(refMat::Particle, ff_cyl);
169  particle_layout.addParticle(particle, 1.0);
170 
171  particle_layout.setInterferenceFunction(*P_interference_function);
172 
173  vacuum_layer.addLayout(particle_layout);
174 
175  MultiLayer* multi_layer = new MultiLayer();
176  multi_layer->addLayer(vacuum_layer);
177  multi_layer->addLayer(substrate_layer);
178  return multi_layer;
179 }
180 
181 // -----------------------------------------------------------------------------
182 // lattice #5: superlattice
183 // -----------------------------------------------------------------------------
184 MultiLayer* SuperLatticeBuilder::buildSample() const
185 {
186  Layer vacuum_layer(refMat::Vacuum);
187  Layer substrate_layer(refMat::Substrate);
188 
189  std::unique_ptr<InterferenceFunction2DSuperLattice> P_interference_function{
190  InterferenceFunction2DSuperLattice::createSquare(200.0 * Units::nanometer, 0.0, 40, 40)};
191  std::unique_ptr<InterferenceFunctionFinite2DLattice> P_substructure{
192  InterferenceFunctionFinite2DLattice::createSquare(10.0 * Units::nanometer, 0.0, 10, 10)};
193  P_interference_function->setSubstructureIFF(*P_substructure);
194  P_interference_function->setPositionVariance(1.0);
195 
196  // particles
197  ParticleLayout particle_layout;
198  FormFactorCylinder ff_cyl(5.0 * Units::nanometer, 10.0 * Units::nanometer);
199  Particle particle(refMat::Vacuum, ff_cyl);
200  particle_layout.addParticle(particle, 1.0, kvector_t(0.0, 0.0, -10.0 * Units::nanometer));
201 
202  particle_layout.setInterferenceFunction(*P_interference_function);
203  particle_layout.setTotalParticleSurfaceDensity(100.0 / 4e4);
204 
205  substrate_layer.addLayout(particle_layout);
206 
207  MultiLayer* multi_layer = new MultiLayer();
208  multi_layer->addLayer(vacuum_layer);
209  multi_layer->addLayer(substrate_layer);
210  return multi_layer;
211 }
FormFactorCylinder.h
Defines class FormFactorCylinder.
InterferenceFunction2DLattice.h
Defines class InterferenceFunction2DLattice.
InterferenceFunction2DSuperLattice.h
Defines class InterferenceFunction2DSuperLattice.
InterferenceFunctionFinite2DLattice.h
Defines class InterferenceFunctionFinite2DLattice.
Layer.h
Defines class Layer.
M_PI
#define M_PI
Definition: MathConstants.h:39
MultiLayer.h
Defines class MultiLayer.
ParticleComposition.h
Defines class ParticleComposition.
ParticleLayout.h
Defines class ParticleLayout.
Particle.h
Defines class Particle.
ReferenceMaterials.h
Defines materials in namespace refMat.
TwoDimLatticeBuilder.h
Defines class IsGISAXS06Builder.
Units.h
Defines some unit conversion factors and other constants in namespace Units.
kvector_t
BasicVector3D< double > kvector_t
Definition: Vectors3D.h:21
Basic2DLatticeBuilder::buildSample
MultiLayer * buildSample() const
Definition: TwoDimLatticeBuilder.cpp:28
FTDecayFunction2DCauchy
Two-dimensional Cauchy decay function in reciprocal space; corresponds to exp(-r) in real space,...
Definition: FTDecay2D.h:63
FormFactorCylinder
A circular cylinder.
Definition: FormFactorCylinder.h:24
IInterferenceFunction::setPositionVariance
void setPositionVariance(double var)
Sets the variance of the position for the calculation of the DW factor It is defined as the variance ...
Definition: IInterferenceFunction.cpp:40
InterferenceFunction2DLattice
Interference function of a 2D lattice.
Definition: InterferenceFunction2DLattice.h:27
InterferenceFunction2DLattice::createSquare
static InterferenceFunction2DLattice * createSquare(double lattice_length, double xi)
Creates square lattice.
Definition: InterferenceFunction2DLattice.cpp:62
InterferenceFunction2DLattice::setDecayFunction
void setDecayFunction(const IFTDecayFunction2D &decay)
Sets two-dimensional decay function.
Definition: InterferenceFunction2DLattice.cpp:79
InterferenceFunction2DSuperLattice::createSquare
static InterferenceFunction2DSuperLattice * createSquare(double lattice_length, double xi, unsigned size_1, unsigned size_2)
Creates square lattice.
Definition: InterferenceFunction2DSuperLattice.cpp:76
InterferenceFunctionFinite2DLattice::createSquare
static InterferenceFunctionFinite2DLattice * createSquare(double lattice_length, double xi, unsigned N_1, unsigned N_2)
Creates square lattice.
Definition: InterferenceFunctionFinite2DLattice.cpp:69
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
ParticleComposition
A composition of particles at fixed positions.
Definition: ParticleComposition.h:25
ParticleComposition::addParticles
void addParticles(const IParticle &particle, std::vector< kvector_t > positions)
Definition: ParticleComposition.cpp:75
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::setTotalParticleSurfaceDensity
void setTotalParticleSurfaceDensity(double particle_density) final override
Sets total particle surface density.
Definition: ParticleLayout.cpp:135
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
SquareLatticeBuilder::buildSample
MultiLayer * buildSample() const
Definition: TwoDimLatticeBuilder.cpp:60
SuperLatticeBuilder::buildSample
MultiLayer * buildSample() const
Definition: TwoDimLatticeBuilder.cpp:184
Units::deg
static constexpr double deg
Definition: Units.h:56
Units::degree
static constexpr double degree
Definition: Units.h:40
Units::nanometer
static constexpr double nanometer
Definition: Units.h:24
anonymous_namespace{InterferenceFunctionHardDisk.cpp}::p
const double p
Definition: InterferenceFunctionHardDisk.cpp:23
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