def get_sample():
"""
Returns a sample with a magnetic core-shell particle in a solvent.
"""
# Defining Materials
mat_solvent = ba.HomogeneousMaterial("Solvent", 5e-6, 0.0)
mat_core = ba.HomogeneousMaterial("Core", 6e-6, 2e-8,
magnetization_core)
mat_shell = ba.HomogeneousMaterial("Shell", 1e-7, 2e-8)
# Defining Layer
solvent_layer = ba.Layer(mat_solvent)
# Defining particle layout with a core-shell particle
layout = ba.ParticleLayout()
core_sphere_ff = ba.FormFactorFullSphere(10*nm)
shell_sphere_ff = ba.FormFactorFullSphere(12*nm)
core = ba.Particle(mat_core, core_sphere_ff)
shell = ba.Particle(mat_shell, shell_sphere_ff)
position = kvector_t(0.0, 0.0, 2.0)
particleCoreShell = ba.ParticleCoreShell(shell, core, position)
layout.addParticle(particleCoreShell)
# Adding layout to layer
solvent_layer.addLayout(layout)
# Defining Multilayer with single layer
multiLayer = ba.MultiLayer()
multiLayer.addLayer(solvent_layer)
return multiLayer
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_vertical_lamellar():
mat_a = ba.HomogeneousMaterial("PTFE", 5.20508729E-6, 1.96944292E-8)
mat_b = ba.HomogeneousMaterial("HMDSO", 2.0888308E-6, 1.32605651E-8)
length = 30*nm
width_a = 4*nm
width_b = 8*nm
height = 30*nm
nstack = 5
stack = ba.ParticleComposition()
for i in range(0, nstack):
box_a = ba.Particle(mat_a, ba.FormFactorBox(length, width_a, height))
box_b = ba.Particle(mat_b, ba.FormFactorBox(length, width_b, height))
stack.addParticle(box_a, ba.kvector_t(0.0, i*(width_a+width_b), 0.0))
stack.addParticle(box_b, ba.kvector_t(0.0, (width_a + width_b)/2. + i*(width_a+width_b), 0.0))
stack.rotate(ba.RotationEuler(45.0*deg, 90.*deg, 0.0))
# Defining particles with parameter following a distribution
gate = ba.DistributionGate(0.0*deg, 180.0*deg)
par_distr = ba.ParameterDistribution("/ParticleComposition/EulerRotation/Alpha", gate, 60, 0.0)
particles = ba.ParticleDistribution(stack, par_distr)
stack.setPosition(0.0, 0.0, width_a/2.)
return particles
def get_sample():
"""
Returns a sample with box-shaped core-shell particles on a substrate.
"""
# defining materials
m_vacuum = ba.HomogeneousMaterial("Vacuum", 0.0, 0.0)
m_shell = ba.HomogeneousMaterial("Shell", 1e-4, 2e-8)
m_core = ba.HomogeneousMaterial("Core", 6e-5, 2e-8)
# collection of particles
parallelepiped1_ff = ba.FormFactorBox(16 * nm, 16 * nm, 8 * nm)
parallelepiped2_ff = ba.FormFactorBox(12 * nm, 12 * nm, 7 * nm)
shell_particle = ba.Particle(m_shell, parallelepiped1_ff)
core_particle = ba.Particle(m_core, parallelepiped2_ff)
core_position = ba.kvector_t(0.0, 0.0, 0.0)
particle = ba.ParticleCoreShell(shell_particle, core_particle,
core_position)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(particle)
interference = ba.InterferenceFunctionNone()
particle_layout.setInterferenceFunction(interference)
vacuum_layer = ba.Layer(m_vacuum)
vacuum_layer.addLayout(particle_layout)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(vacuum_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)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder, 0.5)
particle_layout.addParticle(prism, 0.5)
# interference = ba.InterferenceFunctionRadialParaCrystal(20.0*nm, 1e3*nm)
# pdf = ba.FTDistribution1DGauss(7 * nm)
# interference.setProbabilityDistribution(pdf)
# particle_layout.addInterferenceFunction(interference)
# air layer with particles and substrate form multi layer
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 testSphericalLacuneInSubstrate(self):
"""
Similar to previous. Truncated sphere and sphere are made of air material.
From scattering point of view, both cases should look like an air lacune in substrate.
"""
sphere_radius = 10.0
sphere_shift = 4.0 # shift beneath interface in absolute units
# Sphere truncated from top. Intended to go below interface.
truncatedSphere = ba.Particle(
mAmbience,
ba.FormFactorTruncatedSphere(sphere_radius, sphere_radius * 2,
sphere_radius * 2 - sphere_shift))
truncatedSphere.setPosition(0, 0, -sphere_shift)
reference = self.get_result(truncatedSphere)
# sphere crossing interface to look like truncated sphere above
sphere = ba.Particle(mAmbience, ba.FormFactorFullSphere(sphere_radius))
sphere.setPosition(0, 0, -sphere_shift)
data = self.get_result(sphere)
diff = ba.RelativeDifference(data, reference)
print(diff)
self.assertLess(diff, 1e-10)
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 testSpheresCrossingInterface(self):
"""
Compares two simulation intended to provide identical results.
Simulation #1: full sphere inserted in air layer to cross interface
Simulation #2: full sphere inserted in substrate layer to cross interface
Both spheres are made of same material.
"""
mParticle = ba.HomogeneousMaterial("Ag", 1.245e-5, 5.419e-7)
sphere_radius = 10.0
sphere_shift = 4.0 # shift beneath interface in absolute units
# Sphere intended for air layer and crossing interface
sphere1 = ba.Particle(mParticle,
ba.FormFactorFullSphere(sphere_radius))
sphere1.setPosition(0, 0, -sphere_shift)
reference = self.get_result(particle_to_air=sphere1)
# Sphere intended for substrate layer and crossing interface
sphere2 = ba.Particle(mParticle,
ba.FormFactorFullSphere(sphere_radius))
sphere2.setPosition(0, 0, -sphere_shift)
data = self.get_result(particle_to_substrate=sphere2)
diff = ba.RelativeDifference(data, reference)
print(diff)
self.assertLess(diff, 1e-10)
def testSphericalCupOnTopOfSubstrate(self):
"""
Compares two simulation intended to provide identical results.
Simulation #1: truncated sphere on top of substrate.
Simulation #2: spherical particle crossing the interface.
Both particles are made of same material as substrate. From scattering point of view,
both cases should look like a truncated sphere on top of substrate.
"""
sphere_radius = 10.0
sphere_shift = 4.0 # shift beneath interface in absolute units
# truncated sphere on top of substrate with height 16nm
truncatedSphere = ba.Particle(
mSubstrate,
ba.FormFactorTruncatedSphere(sphere_radius,
sphere_radius * 2 - sphere_shift))
reference = self.get_result(truncatedSphere)
# sphere crossing interface to look like truncated sphere above
sphere = ba.Particle(mSubstrate,
ba.FormFactorFullSphere(sphere_radius))
sphere.setPosition(0, 0, -sphere_shift)
data = self.get_result(sphere)
diff = ba.RelativeDifference(data, reference)
print(diff)
self.assertLess(diff, 1e-10)
def testBoxTransform(self):
"""
Reference box of (10,50,20) size is compared against the box (50,20,10) with two rotations applied to get
reference one
"""
mParticle = ba.HomogeneousMaterial("Ag", 1.245e-5, 5.419e-7)
# reference box
length = 10
width = 50
height = 20
box = ba.Particle(mParticle, ba.FormFactorBox(length, width, height))
box.setPosition(kvector_t(0, 0, -layer_thickness / 2 - height / 2))
reference_data = self.get_result(box)
#IntensityDataIOFactory.writeIntensityData(reference_data, "ref_TransformBox.int")
# second box
length = 50
width = 20
height = 10
box = ba.Particle(mParticle, ba.FormFactorBox(length, width, height))
box.setRotation(ba.RotationZ(90 * deg))
box.rotate(ba.RotationY(90 * deg))
box.setPosition(kvector_t(0, 0, -layer_thickness / 2))
data = self.get_result(box)
diff = ba.RelativeDifference(data, reference_data)
print(diff)
self.assertLess(diff, 1e-10)
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
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():
# Defining Materials
material_1 = ba.HomogeneousMaterial("Air", 0.0, 0.0)
material_2 = ba.MaterialBySLD("Au", 4.6665e-06, -1.6205e-08)
material_3 = ba.MaterialBySLD("Si", 2.0737e-06, -2.3758e-11)
# Defining Layers
layer_1 = ba.Layer(material_1)
layer_2 = ba.Layer(material_3)
formFactor_1 = ba.FormFactorCone6(159.0 * nm, 640.0 * nm, 86.0 * deg)
formFactor_2 = ba.FormFactorCone6(157.0 * nm, 640.0 * nm, 86.0 * deg)
formFactor_3 = ba.FormFactorTruncatedSphere(115.0 * nm, 160.0 * nm,
0.0 * nm)
particle_1 = ba.Particle(material_2, formFactor_1)
particle_2 = ba.Particle(material_3, formFactor_2)
particle_3 = ba.Particle(material_2, formFactor_3)
particle_3_position = kvector_t(0.0 * nm, 0.0 * nm, 640.0 * nm)
particle_3.setPosition(particle_3_position)
# Defining Core Shell Particles
particleCoreShell_1 = ba.ParticleCoreShell(particle_2, particle_1)
particleCoreShell_1_rotation = ba.RotationZ(0 * deg)
particleCoreShell_1.setRotation(particleCoreShell_1_rotation)
# Defining composition of particles at specific positions
particleComposition_1 = ba.ParticleComposition()
particleComposition_1.addParticle(particleCoreShell_1)
particleComposition_1.addParticle(particle_3)
particleComposition_1_rotation = ba.RotationX(0.0 * deg)
particleComposition_1.setRotation(particleComposition_1_rotation)
# Defining Interference Functions
interference_1 = ba.InterferenceFunction2DLattice(
1500.0 * nm, 1500.0 * nm, 120.0 * deg, i * deg)
interference_1_pdf = ba.FTDecayFunction2DCauchy(
1000.0 * nm, 1000.0 * nm, 0.0 * deg)
interference_1.setDecayFunction(interference_1_pdf)
interference_1.setPositionVariance(500.0 * nm2)
# Defining Particle Layouts and adding Particles
layout_1 = ba.ParticleLayout()
layout_1.addParticle(particleComposition_1, 1.0)
layout_1.setInterferenceFunction(interference_1)
layout_1.setTotalParticleSurfaceDensity(0.000001)
# 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 in a homogeneous medium ("Vacuum").
The cylinders are a 95:5 mixture of two different size distributions.
"""
# defining materials
m_vacuum = ba.HomogeneousMaterial("Vacuum", 0.0, 0.0)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# collection of particles #1
radius1 = 5.0 * nm
height1 = radius1
sigma1 = radius1 * 0.2
cylinder_ff1 = ba.FormFactorCylinder(radius1, height1)
cylinder1 = ba.Particle(m_particle, cylinder_ff1)
gauss_distr1 = ba.DistributionGaussian(radius1, sigma1)
nparticles = 150
sigma_factor = 3.0
# limits will assure, that generated Radius'es are >=0
limits = ba.RealLimits.nonnegative()
par_distr1 = ba.ParameterDistribution("/Particle/Cylinder/Radius",
gauss_distr1, nparticles,
sigma_factor, limits)
part_coll1 = ba.ParticleDistribution(cylinder1, par_distr1)
# collection of particles #2
radius2 = 10.0 * nm
height2 = radius2
sigma2 = radius2 * 0.02
cylinder_ff2 = ba.FormFactorCylinder(radius2, height2)
cylinder2 = ba.Particle(m_particle, cylinder_ff2)
gauss_distr2 = ba.DistributionGaussian(radius2, sigma2)
par_distr2 = ba.ParameterDistribution("/Particle/Cylinder/Radius",
gauss_distr2, nparticles,
sigma_factor, limits)
part_coll2 = ba.ParticleDistribution(cylinder2, par_distr2)
# assembling the sample
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(part_coll1, 0.95)
particle_layout.addParticle(part_coll2, 0.05)
vacuum_layer = ba.Layer(m_vacuum)
vacuum_layer.addLayout(particle_layout)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(vacuum_layer)
return multi_layer
def get_sample():
# Defining Materials
material_1 = ba.HomogeneousMaterial("example01_Air", 0.0, 0.0)
material_2 = ba.HomogeneousMaterial("Si", 5.73327e-06, 1.006366e-07)
# Defining Layers
layer_1 = ba.Layer(material_1)
layer_2 = ba.Layer(material_2)
particleComposition_1 = ba.ParticleComposition()
for i in range(nslices):
r = 159 * nm - i * 2
z = i * 15 * nm
y = z + 15 * nm
# Defining Form Factors
formFactor_1 = ba.FormFactorCone6(r, 5.0 * nm, 68.0 * deg)
formFactor_2 = ba.FormFactorCone6(r, 10.0 * nm, 78.0 * deg)
# Defining Particles
particle_1 = ba.Particle(material_2, formFactor_1)
particle_1_rotation = ba.RotationY(180.0 * deg)
particle_1.setRotation(particle_1_rotation)
particle_1_position = kvector_t(0.0 * nm, 0.0 * nm, y * nm)
particle_1.setPosition(particle_1_position)
particle_2 = ba.Particle(material_2, formFactor_2)
particle_2_position = kvector_t(0.0 * nm, 0.0 * nm, z * nm)
particle_2.setPosition(particle_2_position)
# Defining composition of particles at specific positions
particleComposition_1.addParticle(particle_1)
particleComposition_1.addParticle(particle_2)
particleComposition_1_rotation = ba.RotationZ(j * deg)
particleComposition_1.setRotation(particleComposition_1_rotation)
# Defining Particle Layouts and adding Particles
layout_1 = ba.ParticleLayout()
layout_1.addParticle(particleComposition_1, 1.0)
layout_1.setTotalParticleSurfaceDensity(0.001)
# 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 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():
# Defining Materials
material_1 = ba.HomogeneousMaterial("Air", 0.0, 0.0)
material_2 = ba.MaterialBySLD("Au", 4.6665e-06, -1.6205e-08)
material_3 = ba.MaterialBySLD("Si", 2.0737e-06, -2.3758e-11)
material_4 = ba.MaterialBySLD("Fe", 7.9486e-06, -5.9880e-10)
# Defining Layers
layer_1 = ba.Layer(material_1)
layer_2 = ba.Layer(material_3)
formFactor_1 = ba.FormFactorCone6(85 * nm, 385.0 * nm, 86.0 * deg)
formFactor_2 = ba.FormFactorCone6(84 * nm, 385.0 * nm, 86.0 * deg)
formFactor_3 = ba.FormFactorTruncatedSphere(68.0 * nm, 95.0 * nm,
0.0 * nm)
particle_1 = ba.Particle(material_4, formFactor_1)
particle_2 = ba.Particle(material_3, formFactor_2)
particle_3 = ba.Particle(material_2, formFactor_3)
particle_3_position = kvector_t(0.0 * nm, 0.0 * nm, 385.0 * nm)
particle_3.setPosition(particle_3_position)
# Defining Core Shell Particles
particleCoreShell_1 = ba.ParticleCoreShell(particle_2, particle_1)
particleCoreShell_1_rotation = ba.RotationZ(i * deg)
particleCoreShell_1.setRotation(particleCoreShell_1_rotation)
# Defining composition of particles at specific positions
particleComposition_1 = ba.ParticleComposition()
particleComposition_1.addParticle(particleCoreShell_1)
particleComposition_1.addParticle(particle_3)
particleComposition_1_rotation = ba.RotationX(0.0 * deg)
particleComposition_1.setRotation(particleComposition_1_rotation)
# Defining Particle Layouts and adding Particles
layout_1 = ba.ParticleLayout()
layout_1.addParticle(particleComposition_1, 1.0)
layout_1.setTotalParticleSurfaceDensity(0.01)
# 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_composition(self, top_material, bottom_material):
"""
Returns particle composition representing sphere made of two different materials.
Origin of new object is at the bottom of resulting sphere.
"""
topCup = ba.Particle(top_material, ba.FormFactorTruncatedSphere(sphere_radius, sphere_radius*2 - bottom_cup_height))
bottomCup = ba.Particle(bottom_material, ba.FormFactorTruncatedSphere(sphere_radius, sphere_radius*2, sphere_radius*2 - bottom_cup_height))
# origin of resulting sphere will be at the bottom
result = ba.ParticleComposition()
result.addParticle(topCup, kvector_t(0.0, 0.0, bottom_cup_height))
result.addParticle(bottomCup, kvector_t(0.0, 0.0, 0.0))
return result
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 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 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 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(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 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 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 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 testSphericalCupOnTopOfSubstrate(self):
"""
Compares two simulation intended to provide identical results.
Simulation #1: truncated sphere on top of substrate.
Simulation #2: spherical particle composition crossing the interface.
Bottom part of composition is made from substrate material.
both cases should look like a truncated sphere on top of substrate.
"""
# truncated sphere on top of substrate with height 16nm
truncatedSphere = ba.Particle(
mParticle,
ba.FormFactorTruncatedSphere(sphere_radius,
sphere_radius * 2 - bottom_cup_height,
0))
reference = self.get_result(truncatedSphere)
# Particle composition, top part made of same material, as particle. Bottom part made of same material as substrate.
composition = self.get_composition(mParticle, mSubstrate)
composition_shift = bottom_cup_height
composition.setPosition(0, 0, -composition_shift)
data = self.get_result(composition)
diff = ba.RelativeDifference(data, reference)
print(diff)
self.assertLess(diff, 1e-10)
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 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(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
