def get_sample():
"""
Returns a sample with cylinders of two different sizes on a substrate.
The cylinder positions are modelled in Local Monodisperse Approximation.
"""
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# cylindrical particle 1
radius1 = 5 * nm
height1 = radius1
cylinder_ff1 = ba.FormFactorCylinder(radius1, height1)
cylinder1 = ba.Particle(m_particle, cylinder_ff1)
# cylindrical particle 2
radius2 = 8 * nm
height2 = radius2
cylinder_ff2 = ba.FormFactorCylinder(radius2, height2)
cylinder2 = ba.Particle(m_particle, cylinder_ff2)
# interference function1
interference1 = ba.InterferenceFunctionRadialParaCrystal(
16.8 * nm, 1e3 * nm)
pdf = ba.FTDistribution1DGauss(3 * nm)
interference1.setProbabilityDistribution(pdf)
# interference function2
interference2 = ba.InterferenceFunctionRadialParaCrystal(
22.8 * nm, 1e3 * nm)
interference2.setProbabilityDistribution(pdf)
# assembling the sample
particle_layout1 = ba.ParticleLayout()
particle_layout1.addParticle(cylinder1, 0.8)
particle_layout1.setInterferenceFunction(interference1)
particle_layout2 = ba.ParticleLayout()
particle_layout2.addParticle(cylinder2, 0.2)
particle_layout2.setInterferenceFunction(interference2)
air_layer = ba.Layer(m_ambience)
air_layer.addLayout(particle_layout1)
air_layer.addLayout(particle_layout2)
substrate_layer = ba.Layer(m_substrate)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with a grating on a substrate, modelled by triangular ripples
forming a 1D Paracrystal.
"""
# defining materials
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# collection of particles
ripple2_ff = ba.FormFactorRipple2(100 * nm, 20 * nm, 4 * nm, -3.0 * nm)
ripple = ba.Particle(m_particle, ripple2_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(ripple, 1.0)
interference = ba.InterferenceFunction2DLattice(200.0 * nm, 50.0 * nm,
90.0 * deg, 0.0 * deg)
pdf = ba.FTDecayFunction2DGauss(1000. * nm / 2. / numpy.pi,
100. * nm / 2. / numpy.pi)
interference.setDecayFunction(pdf)
particle_layout.setInterferenceFunction(interference)
# air layer with particles and substrate form multi layer
air_layer = ba.Layer(m_ambience)
air_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate, 0)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with cosine ripples on a substrate.
The structure is modelled as a 2D Lattice.
"""
# defining materials
m_vacuum = ba.HomogeneousMaterial("Vacuum", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# collection of particles
ff = ba.FormFactorCosineRippleBox(100 * nm, 20 * nm, 4 * nm)
particle = ba.Particle(m_particle, ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(particle, 1.0)
interference = ba.InterferenceFunction2DLattice(200.0 * nm, 50.0 * nm,
90.0 * deg, 0.0 * deg)
pdf = ba.FTDecayFunction2DCauchy(1000. * nm / 2. / numpy.pi,
100. * nm / 2. / numpy.pi, 0)
interference.setDecayFunction(pdf)
particle_layout.setInterferenceFunction(interference)
# assemble the sample
vacuum_layer = ba.Layer(m_vacuum)
vacuum_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(vacuum_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with magnetic spheres in the substrate.
"""
# defining materials
particle_material = ba.HomogeneousMaterial("Particle", 2e-5, 4e-7,
magnetization_particle)
air_material = ba.HomogeneousMaterial("Air", 0.0, 0.0)
substrate_material = ba.HomogeneousMaterial("Substrate", 7e-6, 1.8e-7)
# spherical magnetic particle
sphere_ff = ba.FormFactorFullSphere(5*nm)
sphere = ba.Particle(particle_material, sphere_ff)
position = ba.kvector_t(0.0, 0.0, -10.0*nm)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(sphere, 1.0, position)
# defining layers
air_layer = ba.Layer(air_material)
substrate_layer = ba.Layer(substrate_material)
substrate_layer.addLayout(particle_layout)
# defining the multilayer
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with boxes on a substrate.
"""
# defining materials
m_air = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 3e-5, 2e-8)
# cylindrical particle
box_ff = ba.FormFactorBox(5 * nm, 5 * nm, 10 * nm)
box = ba.Particle(m_particle, box_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(box)
# interference function
interference = ba.InterferenceFunction2DLattice.createSquare(8 * nm)
pdf = ba.FTDecayFunction2DCauchy(100 * nm, 100 * nm)
interference.setDecayFunction(pdf)
particle_layout.setInterferenceFunction(interference)
air_layer = ba.Layer(m_air)
air_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample(params):
"""
Returns a sample with uncorrelated cylinders and prisms on a substrate.
"""
cylinder_height = params["cylinder_height"]
cylinder_radius = params["cylinder_radius"]
prism_height = params["prism_height"]
prism_base_edge = params["prism_base_edge"]
# defining materials
m_vacuum = ba.HomogeneousMaterial("Vacuum", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# collection of particles
cylinder_ff = ba.FormFactorCylinder(cylinder_radius, cylinder_height)
cylinder = ba.Particle(m_particle, cylinder_ff)
prism_ff = ba.FormFactorPrism3(prism_base_edge, prism_height)
prism = ba.Particle(m_particle, prism_ff)
layout = ba.ParticleLayout()
layout.addParticle(cylinder, 0.5)
layout.addParticle(prism, 0.5)
interference = ba.InterferenceFunctionNone()
layout.setInterferenceFunction(interference)
# vacuum layer with particles and substrate form multi layer
vacuum_layer = ba.Layer(m_vacuum)
vacuum_layer.addLayout(layout)
substrate_layer = ba.Layer(m_substrate, 0)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(vacuum_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with cylinders on a substrate,
forming a 2D lattice with different disorder rotated lattice
"""
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
air_layer = ba.Layer(m_ambience)
substrate_layer = ba.Layer(m_substrate)
p_interference_function = \
ba.InterferenceFunction2DLattice.createSquare(25.0*nm)
pdf = ba.FTDecayFunction2DCauchy(300.0 * nm / 2.0 / numpy.pi,
100.0 * nm / 2.0 / numpy.pi)
p_interference_function.setDecayFunction(pdf)
particle_layout = ba.ParticleLayout()
ff_cyl = ba.FormFactorCylinder(3.0 * nm, 3.0 * nm)
position = ba.kvector_t(0.0, 0.0, 0.0)
cylinder = ba.Particle(m_particle, ff_cyl.clone())
cylinder.setPosition(position)
particle_layout.addParticle(cylinder, 1.0)
particle_layout.setInterferenceFunction(p_interference_function)
air_layer.addLayout(particle_layout)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def getSample():
# Defining Materials
material_2 = ba.HomogeneousMaterial("Si", 7.6e-06, 1.7e-07)
material_1 = ba.HomogeneousMaterial("Air", 0.0, 0.0)
# Defining Layers
layer_1 = ba.Layer(material_1)
layer_2 = ba.Layer(material_2)
# cylindrical particles with bivariate size distribution
radius = 5 * nm # mean radius
height = radius # mean height
nparticles = 10
nfwhm = 2.0
sigma = 0.2 * radius # sx = sy = sigma
distr = BivariateGaussian(mx=radius, my=height, sx=sigma, sy=sigma)
params = distr.gen_parameters(nparticles, nfwhm)
layout_1 = ba.ParticleLayout()
for p in params:
cylinder_ff = ba.FormFactorCylinder(p['radius'], p['height'])
cylinder = ba.Particle(material_2, cylinder_ff)
layout_1.addParticle(cylinder, p['abundance'])
# Adding layouts to layers
layer_1.addLayout(layout_1)
# Defining Multilayers
multiLayer_1 = ba.MultiLayer()
multiLayer_1.addLayer(layer_1)
multiLayer_1.addLayer(layer_2)
return multiLayer_1
def getSample():
# Defining Materials
material_1 = ba.HomogeneousMaterial("Air", 0.0, 0.0)
material_2 = ba.HomogeneousMaterial("Si", 7.6e-06, 1.7e-07)
# Defining Layers
layer_1 = ba.Layer(material_1)
layer_2 = ba.Layer(material_2)
# Defining Form Factors
formFactor_1 = ba.FormFactorBox(20.0 * nm, 20.0 * nm, 10.0 * nm)
# Defining Particles
particle_1 = ba.Particle(material_2, formFactor_1)
# Defining Particle Layouts and adding Particles
layout_1 = ba.ParticleLayout()
layout_1.addParticle(particle_1, 1.0)
layout_1.setTotalParticleSurfaceDensity(1)
# Adding layouts to layers
layer_1.addLayout(layout_1)
# Defining Multilayers
multiLayer_1 = ba.MultiLayer()
multiLayer_1.addLayer(layer_1)
multiLayer_1.addLayer(layer_2)
return multiLayer_1
def get_sample(ff, trafo):
"""Build and return a sample consisting of uncorrelated particles with given
form factor and transformation operator
:param ff: Form factor
:param trafo: Optional rotation
"""
# defining materials
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_particle = ba.HomogeneousMaterial("Particle", 1e-5, 0)
# collection of particles
particle = ba.Particle(m_particle, ff)
particle_layout = ba.ParticleLayout()
if trafo is not None:
particle.setRotation(trafo)
particle_layout.addParticle(particle)
else:
particle_layout.addParticle(particle)
air_layer = ba.Layer(m_ambience)
air_layer.addLayout(particle_layout)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
return multi_layer
def get_sample():
"""
Returns a sample with rotated pyramids on top of a substrate.
"""
# defining materials
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# collection of particles
pyramid_ff = ba.FormFactorPyramid(10*nm, 5*nm, 54.73*deg)
pyramid = ba.Particle(m_particle, pyramid_ff)
transform = ba.RotationZ(45.*deg)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(
pyramid, 1.0, ba.kvector_t(0.0, 0.0, 0.0), transform)
air_layer = ba.Layer(m_ambience)
air_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with cylinders on a substrate, forming a 2D square lattice.
"""
# defining materials
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# collection of particles
interference = ba.InterferenceFunctionFinite2DLattice.createSquare(
25.0 * nm, 0.0, 40, 40)
interference.setPositionVariance(1.0)
cylinder_ff = ba.FormFactorCylinder(3. * nm, 3. * nm)
cylinder = ba.Particle(m_particle, cylinder_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder)
particle_layout.setInterferenceFunction(interference)
# assembling the sample
air_layer = ba.Layer(m_ambience)
air_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
print(multi_layer.parametersToString())
print(multi_layer.treeToString())
return multi_layer
def get_sample(cyl_height=5 * nm):
"""
Returns a sample with cylinders on a substrate.
"""
# defining materials
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_layer = ba.HomogeneousMaterial("Layer", 3e-6, 2e-8)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 3e-5, 2e-8)
# cylindrical particle
cylinder_ff = ba.FormFactorCylinder(5 * nm, cyl_height)
cylinder = ba.Particle(m_particle, cylinder_ff)
position = ba.kvector_t(0.0, 0.0, -cyl_height)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder, 1.0, position)
# interference function
interference = ba.InterferenceFunction2DLattice.createSquare(15 * nm)
pdf = ba.FTDecayFunction2DCauchy(300 * nm, 300 * nm)
interference.setDecayFunction(pdf)
particle_layout.setInterferenceFunction(interference)
air_layer = ba.Layer(m_ambience)
intermediate_layer = ba.Layer(m_layer, 5 * nm)
intermediate_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(intermediate_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with cylinders on a substrate, forming a rotated 2D lattice
"""
# defining materials
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# collection of particles
interference = ba.InterferenceFunction2DLattice.createSquare(
25.0*nm, 30.0*deg)
pdf = ba.FTDecayFunction2DCauchy(
300.0*nm/2.0/numpy.pi, 100.0*nm/2.0/numpy.pi)
pdf.setGamma(30.0*deg)
interference.setDecayFunction(pdf)
cylinder_ff = ba.FormFactorCylinder(3.*nm, 3.*nm)
cylinder = ba.Particle(m_particle, cylinder_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder)
particle_layout.setInterferenceFunction(interference)
# assembling the sample
air_layer = ba.Layer(m_ambience)
air_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with spherical particles on a substrate,
forming a hexagonal 2D lattice.
"""
m_air = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
sphere_ff = ba.FormFactorFullSphere(10.0 * nm)
sphere = ba.Particle(m_particle, sphere_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(sphere)
interference = ba.InterferenceFunction2DLattice.createHexagonal(20.0 * nm)
pdf = ba.FTDecayFunction2DCauchy(10 * nm, 10 * nm)
interference.setDecayFunction(pdf)
particle_layout.setInterferenceFunction(interference)
air_layer = ba.Layer(m_air)
air_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate, 0)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with spheres on a substrate,
forming two hexagonal close packed layers.
"""
m_air = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
radius = 10.0 * nm
sphere_ff = ba.FormFactorFullSphere(radius)
sphere = ba.Particle(m_particle, sphere_ff)
particle_layout = ba.ParticleLayout()
pos0 = ba.kvector_t(0.0, 0.0, 0.0)
pos1 = ba.kvector_t(radius, radius, numpy.sqrt(3.0) * radius)
basis = ba.ParticleComposition()
basis.addParticles(sphere, [pos0, pos1])
particle_layout.addParticle(basis)
interference = ba.InterferenceFunction2DLattice.createHexagonal(radius *
2.0)
pdf = ba.FTDecayFunction2DCauchy(10 * nm, 10 * nm)
interference.setDecayFunction(pdf)
particle_layout.setInterferenceFunction(interference)
air_layer = ba.Layer(m_air)
air_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate, 0)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample(params):
"""
Returns a sample with cylinders and pyramids on a substrate,
forming a hexagonal lattice.
"""
radius = params['radius']
lattice_length = params['length']
m_vacuum = ba.HomogeneousMaterial("Vacuum", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
sphere_ff = ba.FormFactorFullSphere(radius)
sphere = ba.Particle(m_particle, sphere_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(sphere)
interference = ba.InterferenceFunction2DLattice.createHexagonal(
lattice_length)
pdf = ba.FTDecayFunction2DCauchy(10 * nm, 10 * nm, 0)
interference.setDecayFunction(pdf)
particle_layout.setInterferenceFunction(interference)
vacuum_layer = ba.Layer(m_vacuum)
vacuum_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate, 0)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(vacuum_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with spherical particles in an layer between air and substrate.
"""
# defining materials
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_interm_layer = ba.HomogeneousMaterial("IntermLayer", 3.45e-6, 5.24e-9)
m_substrate = ba.HomogeneousMaterial("Substrate", 7.43e-6, 1.72e-7)
m_particle = ba.HomogeneousMaterial("Particle", 0.0, 0.0)
# collection of particles
ff_sphere = ba.FormFactorFullSphere(10.2 * nm)
sphere = ba.Particle(m_particle, ff_sphere)
sphere.setPosition(0.0, 0.0, -25.2)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(sphere, 1.0)
# assembling the sample
air_layer = ba.Layer(m_ambience)
intermediate_layer = ba.Layer(m_interm_layer, 30. * nm)
intermediate_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate, 0)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(intermediate_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with a grating on a substrate,
modelled by infinitely long boxes forming a 1D lattice.
"""
# defining materials
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# collection of particles
lattice_length = 100.0 * nm
lattice_rotation_angle = 0.0 * deg
interference = ba.InterferenceFunction1DLattice(lattice_length,
lattice_rotation_angle)
pdf = ba.FTDecayFunction1DCauchy(1e+6)
interference.setDecayFunction(pdf)
box_ff = ba.FormFactorBox(1000 * nm, 20 * nm, 10.0 * nm)
box = ba.Particle(m_particle, box_ff)
transform = ba.RotationZ(90.0 * deg)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(box, 1.0, ba.kvector_t(0.0, 0.0, 0.0),
transform)
particle_layout.setInterferenceFunction(interference)
# assembling the sample
air_layer = ba.Layer(m_ambience)
air_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample(params):
"""
Returns a sample with uncorrelated cylinders and pyramids on a substrate.
"""
radius = params["radius"]
height = params["height"]
m_vacuum = ba.HomogeneousMaterial("Vacuum", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
cylinder_ff = ba.FormFactorCylinder(radius, height)
cylinder = ba.Particle(m_particle, cylinder_ff)
layout = ba.ParticleLayout()
layout.addParticle(cylinder)
vacuum_layer = ba.Layer(m_vacuum)
vacuum_layer.addLayout(layout)
substrate_layer = ba.Layer(m_substrate, 0)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(vacuum_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample(radius=5.0 * nm, height=5.0 * nm, lattice_constant=10.0 * nm):
"""
Returns a sample with cylinders on a substrate,
forming a rectangular lattice.
"""
m_air = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
ff = ba.FormFactorCylinder(radius, height)
cylinder = ba.Particle(m_particle, ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder)
interference = ba.InterferenceFunction2DLattice(lattice_constant,
lattice_constant,
90.0 * deg)
pdf = ba.FTDecayFunction2DCauchy(50 * nm, 50 * nm)
interference.setDecayFunction(pdf)
particle_layout.setInterferenceFunction(interference)
air_layer = ba.Layer(m_air)
air_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate, 0)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def multilayer(self):
"""
Constructs the sample from current parameter values.
"""
# defining materials
m_air = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_Si = ba.HomogeneousMaterial("Si", 5.78164736e-6, 1.02294578e-7)
m_Ag = ba.HomogeneousMaterial("Ag", 2.24749529E-5, 1.61528396E-6)
m_PTFE = ba.HomogeneousMaterial("PTFE", 5.20508729E-6, 1.96944292E-8)
m_HMDSO = ba.HomogeneousMaterial("HMDSO", 2.0888308E-6, 1.32605651E-8)
# collection of particles with size distribution
nparticles = 20
nfwhm = 2.0
sphere_ff = ba.FormFactorFullSphere(self.radius)
sphere = ba.Particle(m_Ag, sphere_ff)
position = ba.kvector_t(0 * ba.nm, 0 * ba.nm,
-1.0 * self.hmdso_thickness)
sphere.setPosition(position)
ln_distr = ba.DistributionLogNormal(self.radius, self.sigma)
par_distr = ba.ParameterDistribution(
"/Particle/FullSphere/Radius", ln_distr, nparticles, nfwhm,
ba.RealLimits.limited(0.0, self.hmdso_thickness / 2.0))
part_coll = ba.ParticleDistribution(sphere, par_distr)
# interference function
interference = ba.InterferenceFunctionRadialParaCrystal(
self.distance, 1e6 * ba.nm)
interference.setKappa(self.kappa)
interference.setDomainSize(20000.0)
pdf = ba.FTDistribution1DGauss(self.disorder)
interference.setProbabilityDistribution(pdf)
# assembling particle layout
layout = ba.ParticleLayout()
layout.addParticle(part_coll, 1.0)
layout.setInterferenceFunction(interference)
layout.setTotalParticleSurfaceDensity(1)
# roughness
r_ptfe = ba.LayerRoughness(2.3 * ba.nm, 0.3, 5.0 * ba.nm)
r_hmdso = ba.LayerRoughness(1.1 * ba.nm, 0.3, 5.0 * ba.nm)
# layers
air_layer = ba.Layer(m_air)
hmdso_layer = ba.Layer(m_HMDSO, self.hmdso_thickness)
hmdso_layer.addLayout(layout)
ptfe_layer = ba.Layer(m_PTFE, self.ptfe_thickness)
substrate_layer = ba.Layer(m_Si)
# assembling multilayer
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayerWithTopRoughness(hmdso_layer, r_hmdso)
multi_layer.addLayerWithTopRoughness(ptfe_layer, r_ptfe)
multi_layer.addLayer(substrate_layer)
return multi_layer
def getSample():
# Defining Materials
material_2 = ba.HomogeneousMaterial("Si", 7.6e-06, 1.7e-07)
material_1 = ba.HomogeneousMaterial("Air", 0.0, 0.0)
# Defining Layers
layer_1 = ba.Layer(material_1)
layer_2 = ba.Layer(material_2)
# Defining Form Factors
formFactor_1 = ba.FormFactorCylinder(5.0 * nm, 5.0 * nm)
# Defining Particles
particle_1 = ba.Particle(material_2, formFactor_1)
# Defining particles with parameter following a distribution
distr_1 = ba.DistributionGaussian(5.0, 1.0)
par_distr_1 = ba.ParameterDistribution("/Particle/Cylinder/Radius",
distr_1, 10, 2.0)
par_distr_1.linkParameter("/Particle/Cylinder/Height")
particleDistribution_1 = ba.ParticleDistribution(particle_1, par_distr_1)
# Defining Particle Layouts and adding Particles
layout_1 = ba.ParticleLayout()
layout_1.addParticle(particleDistribution_1, 1.0)
layout_1.setTotalParticleSurfaceDensity(1)
# Adding layouts to layers
layer_1.addLayout(layout_1)
# Defining Multilayers
multiLayer_1 = ba.MultiLayer()
multiLayer_1.addLayer(layer_1)
multiLayer_1.addLayer(layer_2)
return multiLayer_1
def get_sample():
"""
Returns a sample with cylinders on a substrate.
"""
# defining materials
m_vacuum = ba.HomogeneousMaterial("Vacuum", 0.0, 0.0)
m_layer = ba.HomogeneousMaterial("Layer", 3e-6, 2e-8)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 3e-5, 2e-8)
# cylindrical particle
half_sphere_ff = ba.FormFactorTruncatedSphere(sphere_radius, sphere_radius,
0)
half_sphere = ba.Particle(m_particle, half_sphere_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(half_sphere)
# interference function
interference = ba.InterferenceFunction2DLattice.createSquare(
10 * nm, 0 * deg)
pdf = ba.FTDecayFunction2DCauchy(100 * nm, 100 * nm, 0)
interference.setDecayFunction(pdf)
particle_layout.setInterferenceFunction(interference)
vacuum_layer = ba.Layer(m_vacuum)
vacuum_layer.addLayout(particle_layout)
vacuum_layer.setNumberOfSlices(n_slices)
substrate_layer = ba.Layer(m_substrate)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(vacuum_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with uncorrelated cylinders and prisms on a substrate.
Parameter set is fixed.
"""
# defining materials
m_air = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# collection of particles
cylinder_ff = ba.FormFactorCylinder(5 * nm, 5 * nm)
cylinder = ba.Particle(m_particle, cylinder_ff)
prism_ff = ba.FormFactorPrism3(5 * nm, 5 * nm)
prism = ba.Particle(m_particle, prism_ff)
layout = ba.ParticleLayout()
layout.addParticle(cylinder, 0.5)
layout.addParticle(prism, 0.5)
interference = ba.InterferenceFunctionNone()
layout.setInterferenceFunction(interference)
# air layer with particles and substrate form multi layer
air_layer = ba.Layer(m_air)
air_layer.addLayout(layout)
substrate_layer = ba.Layer(m_substrate, 0)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with cylinders on a substrate that form a radial paracrystal.
"""
# defining materials
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# collection of particles
cylinder_ff = ba.FormFactorCylinder(5*nm, 5*nm)
cylinder = ba.Particle(m_particle, cylinder_ff)
interference = ba.InterferenceFunctionRadialParaCrystal(
20.0*nm, 1e3*nm)
pdf = ba.FTDistribution1DGauss(7 * nm)
interference.setProbabilityDistribution(pdf)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder, 1.0)
particle_layout.setInterferenceFunction(interference)
# assembling the sample
air_layer = ba.Layer(m_ambience)
air_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
# print(multi_layer.treeToString())
return multi_layer
def get_sample():
"""
Returns a sample with uncorrelated cylinders and prisms on a substrate.
"""
# defining materials
m_vacuum = ba.HomogeneousMaterial("Vacuum", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# collection of particles
cylinder_ff = ba.FormFactorCylinder(5 * nm, 5 * nm)
cylinder = ba.Particle(m_particle, cylinder_ff)
prism_ff = ba.FormFactorPrism3(10 * nm, 5 * nm)
prism = ba.Particle(m_particle, prism_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder, 0.5)
particle_layout.addParticle(prism, 0.5)
interference = ba.InterferenceFunctionNone()
particle_layout.setInterferenceFunction(interference)
# vacuum layer with particles and substrate form multi layer
vacuum_layer = ba.Layer(m_vacuum)
vacuum_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(vacuum_layer)
multi_layer.addLayer(substrate_layer)
print(multi_layer.treeToString())
return multi_layer
def get_sample():
"""
Returns a sample with cylinders on a substrate, forming a 2D paracrystal
"""
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# collection of particles
cylinder_ff = ba.FormFactorCylinder(4 * nm, 5 * nm)
cylinder = ba.Particle(m_particle, cylinder_ff)
interference = ba.InterferenceFunction2DParaCrystal.createSquare(
10.0 * nm, 0.0, 20.0 * micrometer, 20.0 * micrometer)
pdf = ba.FTDistribution2DCauchy(1.0 * nm, 1.0 * nm)
interference.setProbabilityDistributions(pdf, pdf)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder, 1.0)
particle_layout.setInterferenceFunction(interference)
# assembling the sample
air_layer = ba.Layer(m_ambience)
air_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
print(multi_layer.parametersToString())
print(multi_layer.treeToString())
return multi_layer
def get_sample():
"""
Returns a multi layer with substrate/air layers.
Vacuum layer contains cylindrical particles made of two materials.
Particle shifted down to cross interface.
"""
# defining materials
m_vacuum = ba.HomogeneousMaterial("Vacuum", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 3.212e-6, 3.244e-8)
m_top_part = ba.HomogeneousMaterial("Ag", 1.245e-5, 5.419e-7)
m_bottom_part = ba.HomogeneousMaterial("Teflon", 2.900e-6, 6.019e-9)
# collection of particles
composition = get_composition(m_top_part, m_bottom_part)
shift = 10.0 * nm
composition.setPosition(0, 0, -shift) # will be shifted below interface
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(composition)
particle_layout.setTotalParticleSurfaceDensity(1)
# vacuum layer with particles and substrate form multi layer
vacuum_layer = ba.Layer(m_vacuum)
vacuum_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(vacuum_layer)
multi_layer.addLayer(substrate_layer)
print(multi_layer.treeToString())
return multi_layer
def create_layout(self, particle_material):
layout = ba.ParticleLayout()
radius = 5.02
nparticles = 100
sigma = 0.3
gauss_distr = ba.DistributionGaussian(radius, sigma)
# scale_param = math.sqrt(math.log((sigma / radius) ** 2 + 1.0))
# gauss_distr = ba.DistributionLogNormal(radius, scale_param)
particle = ba.Particle(particle_material,
ba.FormFactorFullSphere(radius))
sigma_factor = 2.0
par_distr = ba.ParameterDistribution("/Particle/FullSphere/Radius",
gauss_distr, nparticles,
sigma_factor)
part_coll = ba.ParticleDistribution(particle, par_distr)
layout.addParticle(part_coll, 1.0,
ba.kvector_t(0, 0, -self.m_average_layer_thickness))
for i in range(0, 100):
radius = npr.normal(5.0, 0.3)
if radius < 4.0 or radius > 6.0:
pass
particle = ba.Particle(particle_material,
ba.FormFactorFullSphere(radius))
zbot = -self.m_average_layer_thickness
pos = random_gate(zbot, zbot + 50)
layout.addParticle(particle, 0.05, ba.kvector_t(0, 0, pos))
layout.setTotalParticleSurfaceDensity(0.002)
return layout
