def getSample():
# Defining Materials
material_1 = ba.HomogeneousMaterial("Air", 0.0, 0.0)
material_3 = ba.HomogeneousMaterial("Si", 7.6e-06, 1.7e-07)
material_2 = ba.HomogeneousMaterial("Polymer", 1.99999999995e-06, 1.3e-08)
# Defining Layers
layer_1 = ba.Layer(material_1)
layer_2 = ba.Layer(material_2, 50)
layer_3 = ba.Layer(material_3)
# Defining Form Factors
formFactor_1 = ba.FormFactorBox(20.0 * nm, 20.0 * nm, 10.0 * nm)
# Defining Particles
particle_1 = ba.Particle(material_3, formFactor_1)
# particle_1_rotationY = ba.RotationY(180.0 * deg)
# particle_1.setRotation(particle_1_rotationY)
# particle_1_rotationZ = ba.RotationZ(30.0 * deg)
# particle_1.applyRotation(particle_1_rotationZ)
particle_1_rotation = ba.RotationEuler(-90.0 * deg, 180.0 * deg,
120.0 * deg)
particle_1.setRotation(particle_1_rotation)
particle_1_position = kvector_t(0.0 * nm, 0.0 * nm, -40.0 * nm)
particle_1.setPosition(particle_1_position)
# 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_2.addLayout(layout_1)
# Defining Multilayers
multiLayer_1 = ba.MultiLayer()
multiLayer_1.addLayer(layer_1)
multiLayer_1.addLayer(layer_2)
multiLayer_1.addLayer(layer_3)
return multiLayer_1
def create_diffuse_layout(self):
layout = ba.ParticleLayout()
radius = 5.0
nparticles = 100
sigma = 0.3 * radius
gauss_distr = ba.DistributionGaussian(radius, sigma)
particle = ba.Particle(self.m_adapted_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 + self.m_meso_elevation))
layout.setTotalParticleSurfaceDensity(0.005)
return layout
def get_sample():
# Defining Materials
m_air = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_substrate = ba.HomogeneousMaterial("Substrate", 6e-06, 2e-08)
# Defining Layers
air = ba.Layer(m_air)
substrate = ba.Layer(m_substrate)
# Defining Particle Layouts and adding Particles
layout = ba.ParticleLayout()
layout.addParticle(get_vertical_lamellar(), 1.0, ba.kvector_t(0.0, 0.0, 10.0))
layout.setTotalParticleSurfaceDensity(1e-4)
# Adding layouts to layers
air.addLayout(layout)
# Defining Multilayer
multiLayer = ba.MultiLayer()
multiLayer.addLayer(air)
multiLayer.addLayer(substrate)
return multiLayer
def get_sample():
"""
Defines sample and returns it
"""
# creating materials
m_ambient = ba.MaterialBySLD("Ambient", 0.0, 0.0)
m_layer_mat = ba.MaterialBySLD("Layer", 1e-4, 1e-8,
ba.kvector_t(0.0, 1e8, 0.0))
m_substrate = ba.MaterialBySLD("Substrate", 7e-5, 2e-6)
# creating layers
ambient_layer = ba.Layer(m_ambient)
layer = ba.Layer(m_layer_mat, 10)
substrate_layer = ba.Layer(m_substrate)
# creating multilayer
multi_layer = ba.MultiLayer()
multi_layer.addLayer(ambient_layer)
multi_layer.addLayer(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.HomogeneousMaterial("Au", 3.53665637e-05, 2.9383311e-06)
material_3 = ba.HomogeneousMaterial("Si", 5.73327e-06, 1.006366e-07)
# Defining Layers
layer_1 = ba.Layer(material_1)
layer_2 = ba.Layer(material_3)
# Defining Form Factors
formFactor_1 = ba.FormFactorTruncatedSphere(159.0 * nm, 244.0 * nm, 0.0 * nm)
# Defining Particles
particle_1 = ba.Particle(material_2, formFactor_1)
particle_1_position = kvector_t(0.0 * nm, 0.0 * nm, 333.0 * nm)
particle_1.setPosition(particle_1_position)
# Defining composition of particles at specific positions
particleComposition_1 = ba.ParticleComposition()
particleComposition_1.addParticle(particle_1)
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(lattice_rotation_angle=45*deg):
"""
Returns a sample with a grating on a substrate,
modelled by very long boxes forming a 1D lattice with Cauchy correlations.
"""
# 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)
box_length, box_width, box_height = 10*nm, 10000*nm, 10*nm
lattice_length = 30*nm
# collection of particles
interference = ba.InterferenceFunction1DLattice(
lattice_length, lattice_rotation_angle)
pdf = ba.FTDecayFunction1DCauchy(1000.0)
interference.setDecayFunction(pdf)
box_ff = ba.FormFactorBox(box_length, box_width, box_height)
box = ba.Particle(m_particle, box_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(
box, 1.0, ba.kvector_t(0.0, 0.0, 0.0), ba.RotationZ(lattice_rotation_angle))
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 runSimulation():
# defining materials
mAmbience = ba.HomogeneousMaterial("Vacuum", 0.0, 0.0)
mSubstrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
magnetic_field = ba.kvector_t(0, 0, 0)
magParticle = ba.HomogeneousMaterial("magParticle", 6e-4, 2e-8,
magnetic_field)
# collection of particles
cylinder_ff = ba.FormFactorCylinder(5 * nanometer, 5 * nanometer)
cylinder = ba.Particle(magParticle, cylinder_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder, 1.0)
interference = ba.InterferenceFunctionNone()
particle_layout.setInterferenceFunction(interference)
# vacuum layer with particles and substrate form multi layer
vacuum_layer = ba.Layer(mAmbience)
vacuum_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(mSubstrate, 0)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(vacuum_layer)
multi_layer.addLayer(substrate_layer)
# build and run experiment
simulation = ba.GISASSimulation()
simulation.setDetectorParameters(100, 0 * degree, 2.0 * degree, 100,
0.0 * degree, 2.0 * degree)
simulation.setBeamParameters(1.0 * angstrom, 0.2 * degree, 0.0 * degree)
simulation.setSample(multi_layer)
simulation.setBeamIntensity(1e2)
simulation.runSimulation()
## intensity data
return simulation.result()
def get_sample():
"""
Returns a sample
"""
# defining materials
m_si = ba.MaterialBySLD("Si", sld_Si, sld_Si_im)
m_d2o = ba.MaterialBySLD("D2O", sld_D2O, sld_D2O_im)
m_core = ba.MaterialBySLD("Me3O5:D2O2", 2.0 * 1.0e-06, 0.0)
m_shell = ba.MaterialBySLD("Me3O5:D2O", 3.9 * 1.0e-06, 0.0)
# layer with particles
# calculate average SLD
Vcore = vol(core_radius, core_height)
Vshell = vol(radius, height) - Vcore
f_d2o = 0.7
f_core = (1.0 - f_d2o) / (1 + Vshell / Vcore)
f_shell = (1.0 - f_d2o) / (1 + Vcore / Vshell)
sld_mix = f_d2o * sld_D2O + f_shell * 3.9 * 1.0e-06 + f_core * 2.0 * 1.0e-06
m_mix = ba.MaterialBySLD("mix", sld_mix, 0.0)
# fluctuation component
ff_microgel = FormFactorMicrogel(b, xi, xiz)
microgel = ba.Particle(m_core, ff_microgel)
microgel_layout = ba.ParticleLayout()
microgel_layout.addParticle(microgel, 1.0)
# collection of particles
ff = ba.FormFactorTruncatedSphere(radius=radius, height=height)
ff_core = ba.FormFactorTruncatedSphere(radius=core_radius,
height=core_height)
transform = ba.RotationY(180.0 * deg)
shell_particle = ba.Particle(m_shell, ff)
core_particle = ba.Particle(m_core, ff_core)
core_position = ba.kvector_t(0.0, 0.0, 0.0)
particle = ba.ParticleCoreShell(shell_particle, core_particle,
core_position)
particle.setPosition(ba.kvector_t(0.0, 0.0, 0.0))
particle.setRotation(transform)
nparticles = 2 # the larger is this number, the more slow will be the simulation. 10 is usually enough
sigma = 0.2 * radius
gauss_distr = ba.DistributionGaussian(radius, sigma)
sigma_factor = 2.0
par_distr = ba.ParameterDistribution(
"/ParticleCoreShell/Particle1/TruncatedSphere/Radius",
gauss_distr, nparticles, sigma_factor,
ba.RealLimits.lowerLimited(core_radius + 1.0))
par_distr.linkParameter(
"/ParticleCoreShell/Particle1/TruncatedSphere/Height")
par_distr.linkParameter(
"/ParticleCoreShell/Particle0/TruncatedSphere/Height")
par_distr.linkParameter(
"/ParticleCoreShell/Particle0/TruncatedSphere/Radius")
part_coll = ba.ParticleDistribution(particle, par_distr)
microgel_layout.addParticle(part_coll, 1.2e-05)
# interference can be neglected
interference = ba.InterferenceFunctionNone()
microgel_layout.setInterferenceFunction(interference)
# describe layer roughness
roughness = ba.LayerRoughness()
roughness.setSigma(1.2 * ba.nm)
roughness.setHurstParameter(0.8)
roughness.setLatteralCorrLength(570.0 * ba.nm)
# create layers
d2o_layer = ba.Layer(m_d2o)
mix_layer = ba.Layer(m_mix, 2.0 * height)
mix_layer.addLayout(microgel_layout)
si_layer = ba.Layer(m_si)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(si_layer)
multi_layer.addLayer(mix_layer)
multi_layer.addLayerWithTopRoughness(d2o_layer, roughness)
return multi_layer
"""
Simulation demo: magnetic spheres in substrate
"""
import bornagain as ba
from bornagain import deg, angstrom, nm
# Magnetization of the particle's material (A/m)
magnetization_particle = ba.kvector_t(0.0, 0.0, 1e7)
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)
plt.figure()
for d, l in zip(data, labels):
plt.semilogy(axis, d, label=l, linewidth=1)
plt.legend(loc='upper right')
plt.gca().yaxis.set_ticks_position('both')
plt.gca().xaxis.set_ticks_position('both')
plt.xlabel(r"$\alpha_i$ [deg]")
plt.ylabel("Reflectivity")
plt.tight_layout()
if __name__ == '__main__':
q, results_pp = run_simulation(ba.kvector_t(0, 1, 0),
ba.kvector_t(0, 1, 0))
q, results_mm = run_simulation(ba.kvector_t(0, -1, 0),
ba.kvector_t(0, -1, 0))
q, results_pm = run_simulation(ba.kvector_t(0, 1, 0),
ba.kvector_t(0, -1, 0))
q, results_mp = run_simulation(ba.kvector_t(0, -1, 0),
ba.kvector_t(0, 1, 0))
r_plus = results_pp + results_pm
r_minus = results_mm + results_mp
plot(q, [r_plus, r_minus], ["$+$", "$-$"])
# same result, but need half the computational time
q, results_p = run_simulation(ba.kvector_t(0, 1, 0))
"""
import numpy
import matplotlib.pyplot as plt
import bornagain as ba
from bornagain import deg, angstrom
sldFe = (8.0241e-06, 6.0448e-10)
sldPd = (4.0099e-6, 1.3019e-09)
sldMgO = (5.9803e-06, 9.3996e-12)
magnetizationMagnitude = 1.6e6
angle = 0
magnetizationVector = ba.kvector_t(
magnetizationMagnitude * numpy.sin(angle * deg),
magnetizationMagnitude * numpy.cos(angle * deg),
0)
def get_sample(*, magnetization=magnetizationVector):
"""
Define sample and returns it
"""
# create materials
mat_vacuum = ba.MaterialBySLD("Vacuum", 0.0, 0.0)
mat_Pd = ba.MaterialBySLD("Pd", *sldPd)
mat_Fe = ba.MaterialBySLD("Fe", *sldFe,
magnetizationVector)
mat_substrate = ba.MaterialBySLD("MgO", *sldMgO)
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)
# Defining Form Factors
formFactor_1 = ba.FormFactorCone6(159.0 * nm, 10.0 * nm, 78.0 * deg)
formFactor_2 = ba.FormFactorCone6(159.0 * nm, 5.0 * nm, 66.0 * deg)
formFactor_3 = ba.FormFactorPrism6(159.0 * nm, 300.0 * nm)
particleComposition_11 = ba.ParticleComposition()
for i in range(nslices):
z = i * 15.0 * nm
y = z + 15.0 * nm
# Defining Particles
particle_1 = ba.Particle(material_2, formFactor_1)
particle_1_position = kvector_t(0.0 * nm, 0.0 * nm, z * nm)
particle_1.setPosition(particle_1_position)
particle_2 = ba.Particle(material_2, formFactor_2)
particle_2_rotation = ba.RotationY(180.0 * deg)
particle_2.setRotation(particle_2_rotation)
particle_2_position = kvector_t(0.0 * nm, 0.0 * nm, y * nm)
particle_2.setPosition(particle_2_position)
particleComposition_11.addParticle(particle_1)
particleComposition_11.addParticle(particle_2)
particleComposition_11_rotation = ba.RotationZ(j * deg)
particleComposition_11.setRotation(particleComposition_11_rotation)
particle_3 = ba.Particle(material_2, formFactor_3)
particle_3_rotation = ba.RotationY(30.0 * deg)
particle_3.setRotation(particle_3_rotation)
particle_3_position = kvector_t(0.0 * nm, 0.0 * nm, 79.5 * nm)
particle_3.setPosition(particle_3_position)
z1 = j
z2 = j + 120
z3 = j + 240
particleComposition_1 = ba.ParticleComposition()
particleComposition_1.addParticle(particle_3)
particleComposition_1_rotation = ba.RotationZ(z1 * deg)
particleComposition_1.setRotation(particleComposition_1_rotation)
particleComposition_2 = ba.ParticleComposition()
particleComposition_2.addParticle(particle_3)
particleComposition_2_rotation = ba.RotationZ(z2 * deg)
particleComposition_2.setRotation(particleComposition_2_rotation)
particleComposition_3 = ba.ParticleComposition()
particleComposition_3.addParticle(particle_3)
particleComposition_3_rotation = ba.RotationZ(z3 * deg)
particleComposition_3.setRotation(particleComposition_3_rotation)
# Defining Particle Layouts and adding Particles
layout_1 = ba.ParticleLayout()
layout_1.addParticle(particleComposition_11, 0.7)
layout_1.addParticle(particleComposition_1, 0.1)
layout_1.addParticle(particleComposition_2, 0.1)
layout_1.addParticle(particleComposition_3, 0.1)
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
"""
Simple example demonstrating how polarized SANS experiments can be
simulated with BornAgain.
"""
import bornagain as ba
from bornagain import deg, nm, kvector_t
# Magnetization of the particle's core material (A/m)
magnetization_core = kvector_t(0.0, 0.0, 1e7)
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)
Runs simulation and returns its result.
"""
sample = get_sample()
simulation = get_simulation()
# adding polarization and analyzer operator
simulation.setBeamPolarization(polarization)
simulation.setAnalyzerProperties(analyzer, 1.0, 0.5)
simulation.setSample(sample)
simulation.runSimulation()
return simulation.result()
def plot(pp, mm):
from matplotlib import pyplot as plt
ba.plot_simulation_result(pp, postpone_show=True)
plt.semilogy(mm.axis(), mm.array())
plt.legend(['Up-Up', 'Down-Down'], loc='upper right')
plt.show()
if __name__ == '__main__':
results_pp = run_simulation(ba.kvector_t(0.0, 1.0, 0.0),
ba.kvector_t(0.0, 1.0, 0.0))
results_mm = run_simulation(ba.kvector_t(0.0, -1.0, 0.0),
ba.kvector_t(0.0, -1.0, 0.0))
plot(results_pp, results_mm)
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_1):
r = 159
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)
for i in range(nslices_2):
r = 159 * nm - i * 2
z = i * 15 * nm
z2 = z + nslices_1 * 15 * nm
y = z + 15 * nm
y2 = y + +nslices_1 * 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, y2 * 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, z2 * 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 buildSample(self):
# 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.value)
# sphere_ff = ba.FormFactorTruncatedSphere(
# self.radius.value, self.radius.value*1.5)
sphere = ba.Particle(m_Ag, sphere_ff)
position = ba.kvector_t(0 * ba.nm, 0 * ba.nm,
-1.0 * self.hmdso_thickness.value)
sphere.setPosition(position)
ln_distr = ba.DistributionLogNormal(self.radius.value,
self.sigma.value)
par_distr = ba.ParameterDistribution("/Particle/FullSphere/Radius",
ln_distr, nparticles, nfwhm)
# par_distr = ba.ParameterDistribution(
# "/Particle/TruncatedSphere/Radius", ln_distr, nparticles, nfwhm)
# par_distr.linkParameter("/Particle/TruncatedSphere/Height")
part_coll = ba.ParticleDistribution(sphere, par_distr)
# interference function
interference = ba.InterferenceFunctionRadialParaCrystal(
self.distance.value, 1e6 * ba.nm)
interference.setKappa(self.kappa.value)
interference.setDomainSize(20000.0)
pdf = ba.FTDistribution1DGauss(self.disorder.value)
interference.setProbabilityDistribution(pdf)
# assembling particle layout
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(part_coll, 1.0)
particle_layout.addInterferenceFunction(interference)
particle_layout.setApproximation(ba.ILayout.SSCA)
particle_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.value)
hmdso_layer.addLayout(particle_layout)
ptfe_layer = ba.Layer(m_PTFE, self.ptfe_thickness.value)
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 run_Simulation_mm(qzs, params):
return run_simulation(qzs,
params,
polarization=ba.kvector_t(0, -1, 0),
analyzer=ba.kvector_t(0, -1, 0))
