def get_sample():
# Defining Materials
material_1 = ba.HomogeneousMaterial("Air", 0.0, 0.0)
material_2 = ba.HomogeneousMaterial("Si", 7.6e-06, 1.7e-07)
material_3 = ba.HomogeneousMaterial("Nb", 2.4e-05, 1.5e-06)
# Defining Layers
layer_1 = ba.Layer(material_1)
layer_2 = ba.Layer(material_2, 3)
layer_3 = ba.Layer(material_3, 5.8)
layer_4 = ba.Layer(material_2)
# Defining Roughness Parameters
layerRoughness_1 = ba.LayerRoughness(sigma_start, 0.5, 10.0*nm)
# Defining Multilayers
multiLayer_1 = ba.MultiLayer()
multiLayer_1.setCrossCorrLength(200)
multiLayer_1.addLayer(layer_1)
for i in range(10):
sigma = decreasing_rms(10 - i)
roughness = ba.LayerRoughness(sigma, 0.5, 10.0*nm)
multiLayer_1.addLayerWithTopRoughness(layer_2, roughness)
multiLayer_1.addLayer(layer_3)
multiLayer_1.addLayerWithTopRoughness(layer_4, layerRoughness_1)
return multiLayer_1
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 get_sample(slabs):
"""
Defines sample and returns it. Note that SLD-based materials are used.
"""
# creating materials
multi_layer = ba.MultiLayer()
ambient = ba.MaterialBySLD("ma", slabs[0, 1] * 1e-6, 0)
layer = ba.Layer(ambient)
multi_layer.addLayer(layer)
for slab in slabs[1:-1]:
material = ba.MaterialBySLD("stuff", slab[1] * 1e-6, slab[2] * 1e-6)
layer = ba.Layer(material, slab[0] * angstrom)
roughness = ba.LayerRoughness()
roughness.setSigma(slab[3] * angstrom)
multi_layer.addLayerWithTopRoughness(layer, roughness)
substrate = ba.MaterialBySLD("msub", slabs[-1, 1] * 1e-6, 0)
layer = ba.Layer(substrate)
roughness = ba.LayerRoughness()
roughness.setSigma(slabs[-1, 3] * angstrom)
multi_layer.addLayerWithTopRoughness(layer, roughness)
multi_layer.setRoughnessModel(ba.RoughnessModel.NEVOT_CROCE)
return multi_layer
def get_sample(params):
"""
construct the sample with the given parameters
"""
magnetizationMagnitude = params["rhoM_Mafo"] * 1e-6 / RhoMconst
angle = 0
magnetizationVector = ba.kvector_t(
magnetizationMagnitude * numpy.sin(angle * deg),
magnetizationMagnitude * numpy.cos(angle * deg), 0)
mat_vacuum = ba.MaterialBySLD("Vacuum", 0.0, 0.0)
mat_layer = ba.MaterialBySLD("(Mg,Al,Fe)3O4", params["rho_Mafo"] * 1e-6, 0,
magnetizationVector)
mat_substrate = ba.MaterialBySLD("MgAl2O4", *sldMao)
ambient_layer = ba.Layer(mat_vacuum)
layer = ba.Layer(mat_layer, params["t_Mafo"] * angstrom)
substrate_layer = ba.Layer(mat_substrate)
r_Mafo = ba.LayerRoughness()
r_Mafo.setSigma(params["r_Mafo"] * angstrom)
r_substrate = ba.LayerRoughness()
r_substrate.setSigma(params["r_Mao"] * angstrom)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(ambient_layer)
multi_layer.addLayerWithTopRoughness(layer, r_Mafo)
multi_layer.addLayerWithTopRoughness(substrate_layer, r_substrate)
return multi_layer
def buildSample(arg_dict):
"""
Creates sample and returns it
"""
# defining materials
m_air = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_si_o2 = ba.HomogeneousMaterial(
"SiO2", 8.57040868e-06 * arg_dict["concentration"],
1.11016654e-07 * arg_dict["concentration"])
m_si = ba.HomogeneousMaterial("Si", 7.57211137e-06, 1.72728178e-07)
# roughness
r_si = ba.LayerRoughness(arg_dict["roughness"], 0, 0)
# layers
air_layer = ba.Layer(m_air)
oxide_layer = ba.Layer(m_si_o2, arg_dict["thickness"])
substrate_layer = ba.Layer(m_si)
# assembling multilayer
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayerWithTopRoughness(oxide_layer, r_si)
multi_layer.addLayerWithTopRoughness(substrate_layer, r_si)
return multi_layer
def create_sample(wavelength):
"""
Creates multilayer.
"""
m_air_material = get_air(wavelength)
m_substrate_material = get_si(wavelength)
m_particle_material = get_iron_oxide(wavelength)
m_average_layer_thickness = 1000 * nm
m_roughness = 1.0 * nm
multi_layer = ba.MultiLayer()
air_layer = ba.Layer(m_air_material)
avg_layer = ba.Layer(m_air_material, m_average_layer_thickness)
meso_layout = create_mesocrystal_layout(m_particle_material,
m_average_layer_thickness)
avg_layer.addLayout(meso_layout)
diffuse_layout = create_diffuse_layout(m_particle_material,
m_average_layer_thickness)
avg_layer.addLayout(diffuse_layout)
substrate_layer = ba.Layer(m_substrate_material)
roughness = ba.LayerRoughness(m_roughness, 0.3, 500.0 * nm)
multi_layer.addLayer(air_layer)
multi_layer.addLayer(avg_layer)
multi_layer.addLayerWithTopRoughness(substrate_layer, roughness)
return multi_layer
def get_sample():
# Defining Materials
material_1 = ba.HomogeneousMaterial("Air", 0.0, 0.0)
material_2 = ba.HomogeneousMaterial("Si", 7.6e-06, 1.7e-07)
material_3 = ba.HomogeneousMaterial("Nb", 2.4e-05, 1.5e-06)
# Defining Layers
layer_1 = ba.Layer(material_1)
layer_2 = ba.Layer(material_2, 3)
layer_3 = ba.Layer(material_3, 5.8)
layer_4 = ba.Layer(material_2)
# Defining Roughness Parameters
layerRoughness_1 = ba.LayerRoughness(0.46, 0.5, 10.0 * nm)
# Defining Multilayers
multiLayer_1 = ba.MultiLayer()
# uncomment the line below to add vertical cross correlation length
# multiLayer_1.setCrossCorrLength(200)
multiLayer_1.addLayer(layer_1)
#=================================
# put your code here
multiLayer_1.addLayer(layer_2)
multiLayer_1.addLayer(layer_3)
#==================================
multiLayer_1.addLayerWithTopRoughness(layer_4, layerRoughness_1)
return multiLayer_1
def get_sample(bilayers, interfacewidth, crosscorrlength, lattcorrlength):
"""
Returns a sample with two layers on a substrate, with correlated roughnesses.
"""
# defining materials
m_ambience = ba.HomogeneousMaterial("ambience", 0.0, 0.0)
m_Ni = ba.MaterialBySLD("Ni", -1.9493e-06, 0.0)
m_Ti = ba.MaterialBySLD("Ti", 9.4245e-06, 0.0)
m_substrate = ba.MaterialBySLD("Substrate", 2.0704e-06, 0.0)
# defining layers
l_ambience = ba.Layer(m_ambience)
l_Ni = ba.Layer(m_Ni, 22 * angstrom)
l_Ti = ba.Layer(m_Ti, 26 * angstrom)
l_substrate = ba.Layer(m_substrate)
roughness = ba.LayerRoughness()
roughness.setSigma(interfacewidth * angstrom)
roughness.setHurstParameter(0.8)
roughness.setLatteralCorrLength(lattcorrlength * angstrom)
my_sample = ba.MultiLayer()
# adding layers
my_sample.addLayer(l_ambience)
n_repetitions = bilayers
for i in range(n_repetitions):
my_sample.addLayerWithTopRoughness(l_Ni, roughness)
my_sample.addLayerWithTopRoughness(l_Ti, roughness)
my_sample.addLayerWithTopRoughness(l_substrate, roughness)
my_sample.setCrossCorrLength(crosscorrlength * angstrom)
print(my_sample.treeToString())
return my_sample
def build_sample(self, wavelength=None):
"""
Constructs multilayer with collection of mesocrystals.
"""
self.init_materials()
multi_layer = ba.MultiLayer()
air_layer = ba.Layer(self.m_air_material)
avg_layer = ba.Layer(self.m_average_layer_material,
self.m_average_layer_thickness)
layout = self.create_layout()
avg_layer.addLayout(layout)
avg_layer.addLayout(self.create_diffuse_layout())
substrate_layer = ba.Layer(self.m_substrate_material)
roughness = ba.LayerRoughness(self.m_roughness, 0.3, 500.0 * nm)
multi_layer.addLayer(air_layer)
multi_layer.addLayer(avg_layer)
multi_layer.addLayerWithTopRoughness(substrate_layer, roughness)
return multi_layer
def get_sample():
"""
Defines sample and returns it
"""
# creating materials
m_ambient = ba.MaterialBySLD("Ambient", 0.0, 0.0)
m_ti = ba.MaterialBySLD("Ti", -1.9493e-06, 0.0)
m_ni = ba.MaterialBySLD("Ni", 9.4245e-06, 0.0)
m_substrate = ba.MaterialBySLD("SiSubstrate", 2.0704e-06, 0.0)
# creating layers
ambient_layer = ba.Layer(m_ambient)
ti_layer = ba.Layer(m_ti, 30 * angstrom)
ni_layer = ba.Layer(m_ni, 70 * angstrom)
substrate_layer = ba.Layer(m_substrate)
# create roughness
roughness = ba.LayerRoughness(5 * angstrom, 0.5, 10 * angstrom)
# creating multilayer
multi_layer = ba.MultiLayer()
multi_layer.addLayer(ambient_layer)
for i in range(4):
multi_layer.addLayerWithTopRoughness(ti_layer, roughness)
multi_layer.addLayerWithTopRoughness(ni_layer, roughness)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with two layers on a substrate, with correlated roughnesses.
"""
m_ambience = ba.HomogeneousMaterial("ambience", 0.0, 0.0)
m_part_a = ba.HomogeneousMaterial("PartA", 5e-6, 0.0)
m_part_b = ba.HomogeneousMaterial("PartB", 10e-6, 0.0)
m_substrate = ba.HomogeneousMaterial("substrate", 15e-6, 0.0)
l_ambience = ba.Layer(m_ambience)
l_part_a = ba.Layer(m_part_a, 5.0 * nm)
l_part_b = ba.Layer(m_part_b, 10.0 * nm)
l_substrate = ba.Layer(m_substrate)
roughness = ba.LayerRoughness()
roughness.setSigma(1.0 * nm)
roughness.setHurstParameter(0.3)
roughness.setLatteralCorrLength(500.0 * nm)
my_sample = ba.MultiLayer()
# adding layers
my_sample.addLayer(l_ambience)
n_repetitions = 10
for i in range(n_repetitions):
my_sample.addLayerWithTopRoughness(l_part_a, roughness)
my_sample.addLayerWithTopRoughness(l_part_b, roughness)
my_sample.addLayerWithTopRoughness(l_substrate, roughness)
return my_sample
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)
# create layers
layer_vacuum = ba.Layer( mat_vacuum )
layer_Pd = ba.Layer( mat_Pd, 120 * angstrom )
layer_Fe = ba.Layer( mat_Fe, 1000 * angstrom )
layer_substrate = ba.Layer( mat_substrate )
roughness = ba.LayerRoughness()
roughness.setSigma( 20 * angstrom)
# create sample
multi_layer = ba.MultiLayer()
multi_layer.addLayer(layer_vacuum)
multi_layer.addLayerWithTopRoughness(layer_Pd, roughness)
multi_layer.addLayerWithTopRoughness(layer_Fe, roughness)
multi_layer.addLayerWithTopRoughness(layer_substrate, roughness)
return multi_layer
def get_sample(nlayers=3):
"""
Construct resonator with given number of Ti/Pt double layers nlayers.
"""
# define materials
m_Si = ba.HomogeneousMaterial("Si", 8.25218379931e-06, 0.0)
m_Ti = ba.HomogeneousMaterial("Ti", -7.6593316363e-06, 3.81961616312e-09)
m_TiO2 = ba.HomogeneousMaterial("TiO2", 1.04803530026e-05,
2.03233519385e-09)
m_Pt = ba.HomogeneousMaterial("Pt", 2.52936993309e-05, 7.54553992473e-09)
m_D2O = ba.HomogeneousMaterial("D2O", 2.52897204573e-05, 4.5224432814e-13)
# create layers
l_TiO2 = ba.Layer(m_TiO2, 3.0 * nm)
l_Ti_top = ba.Layer(m_Ti, 10.0 * nm)
l_Ti = ba.Layer(m_Ti, 13.0 * nm)
l_Si = ba.Layer(m_Si) # consider it as an ambient layer
l_Pt = ba.Layer(m_Pt, 32.0 * nm)
l_D2O = ba.Layer(
m_D2O) # thickness is not given, seems to be like a substrate
# describe layer roughness
roughness = ba.LayerRoughness()
roughness.setSigma(2.0 * nm)
roughness.setHurstParameter(0.8)
roughness.setLatteralCorrLength(10.0 * micrometer)
# assemble multilayer
sample = ba.MultiLayer()
sample.addLayer(l_Si) # Assume huge Si block to be infinite
for i in range(nlayers):
sample.addLayerWithTopRoughness(l_Ti, roughness)
sample.addLayerWithTopRoughness(l_Pt, roughness)
sample.addLayerWithTopRoughness(l_Ti_top, roughness)
sample.addLayerWithTopRoughness(l_TiO2, roughness)
sample.addLayerWithTopRoughness(l_D2O, roughness)
sample.setCrossCorrLength(400 * nm)
return sample
def get_sample(lattice_rotation_angle=0.0 * deg):
"""
Returns a sample with a grating on a substrate.
lattice_rotation_angle = 0 - beam parallel to grating lines
lattice_rotation_angle = 90*deg - beam perpendicular to grating lines
"""
# defining materials
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_si = ba.HomogeneousMaterial("Si", 5.78164736e-6, 1.02294578e-7)
box_length, box_width, box_height = 50 * micrometer, 70 * nm, 50 * nm
lattice_length = 150 * nm
# collection of particles
interference = ba.InterferenceFunction1DLattice(
lattice_length, 90.0 * deg - lattice_rotation_angle)
pdf = ba.ba.FTDecayFunction1DGauss(450.0)
interference.setDecayFunction(pdf)
box_ff = ba.FormFactorLongBoxLorentz(box_length, box_width, box_height)
box = ba.Particle(m_si, 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_si)
roughness = ba.LayerRoughness()
roughness.setSigma(5.0 * nm)
roughness.setHurstParameter(0.5)
roughness.setLatteralCorrLength(10.0 * nm)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayerWithTopRoughness(substrate_layer, roughness)
return multi_layer
def build_sample(self, wavelength=None):
"""
Constructs multilayer with collection of mesocrystals.
"""
self.init_materials(wavelength)
multi_layer = ba.MultiLayer()
air_layer = ba.Layer(self.m_air_material)
avg_layer = ba.Layer(self.m_air_material, self.m_average_layer_thickness)
substrate_layer = ba.Layer(self.m_substrate_material)
for layout_factory in self.m_layouts:
avg_layer.addLayout(layout_factory.create_layout(self.m_particle_material))
roughness = ba.LayerRoughness(self.m_roughness, 0.3, 500.0*nm)
multi_layer.addLayer(air_layer)
multi_layer.addLayer(avg_layer)
multi_layer.addLayerWithTopRoughness(substrate_layer, roughness)
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)
# Defining Form Factors
formFactor_1 = ba.FormFactorCone6(90.0 * nm, 270.0 * nm, 75.0 * deg)
formFactor_2 = ba.FormFactorCone6(88.0 * nm, 270.0 * nm, 75.0 * deg)
# Defining Particles
particle_1 = ba.Particle(material_2, formFactor_1)
particle_2 = ba.Particle(material_3, formFactor_2)
# 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 Particle Layouts and adding Particles
layout_1 = ba.ParticleLayout()
layout_1.addParticle(particleCoreShell_1, 1.0)
layout_1.setTotalParticleSurfaceDensity(0.001)
# Defining Roughness Parameters
layerRoughness_1 = ba.LayerRoughness(1.0, 0.3, 5.0 * nm)
# Adding layouts to layers
layer_1.addLayout(layout_1)
# Defining Multilayers
multiLayer_1 = ba.MultiLayer()
multiLayer_1.addLayer(layer_1)
multiLayer_1.addLayerWithTopRoughness(layer_2, layerRoughness_1)
return multiLayer_1
def get_sample():
"""
Defines sample and returns it
"""
# creating materials
m_ambient = ba.MaterialBySLD("Ambient", 0.0, 0.0)
m_ti = ba.MaterialBySLD("Ti", -1.9493e-06, 0.0)
m_ni = ba.MaterialBySLD("Ni", 9.4245e-06, 0.0)
m_particle = ba.MaterialBySLD("Particle", 5e-6, 0.0)
m_substrate = ba.MaterialBySLD("SiSubstrate", 2.0704e-06, 0.0)
# creating layers
ambient_layer = ba.Layer(m_ambient)
ti_layer = ba.Layer(m_ti, 30 * angstrom)
ni_layer = ba.Layer(m_ni, 70 * angstrom)
substrate_layer = ba.Layer(m_substrate)
# create roughness
roughness = ba.LayerRoughness(5 * angstrom, 0.5, 10 * angstrom)
# create particle layout
ff = ba.FormFactorCone(5 * nm, 10 * nm, 75 * deg)
particle = ba.Particle(m_particle, ff)
layout = ba.ParticleLayout()
layout.addParticle(particle)
iff = ba.InterferenceFunction2DLattice.createSquare(10 * nm, 0)
layout.setInterferenceFunction(iff)
ambient_layer.addLayout(layout)
ambient_layer.setNumberOfSlices(20)
# creating multilayer
multi_layer = ba.MultiLayer()
multi_layer.addLayer(ambient_layer)
for i in range(2):
multi_layer.addLayerWithTopRoughness(ti_layer, roughness)
multi_layer.addLayerWithTopRoughness(ni_layer, roughness)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
Returns a sample with two layers on a substrate, with correlated roughnesses.
"""
# defining materials
m_vacuum = ba.HomogeneousMaterial("ambience", 0.0, 0.0)
m_part_a = ba.HomogeneousMaterial("PartA", 5e-6, 0.0)
m_part_b = ba.HomogeneousMaterial("PartB", 10e-6, 0.0)
m_substrate = ba.HomogeneousMaterial("substrate", 15e-6, 0.0)
# defining layers
l_ambience = ba.Layer(m_vacuum)
l_part_a = ba.Layer(m_part_a, 2.5 * nm)
l_part_b = ba.Layer(m_part_b, 5.0 * nm)
l_substrate = ba.Layer(m_substrate)
roughness = ba.LayerRoughness()
roughness.setSigma(1.0 * nm)
roughness.setHurstParameter(0.3)
roughness.setLatteralCorrLength(5.0 * nm)
my_sample = ba.MultiLayer()
# adding layers
my_sample.addLayer(l_ambience)
n_repetitions = 5
for i in range(n_repetitions):
my_sample.addLayerWithTopRoughness(l_part_a, roughness)
my_sample.addLayerWithTopRoughness(l_part_b, roughness)
my_sample.addLayerWithTopRoughness(l_substrate, roughness)
my_sample.setCrossCorrLength(10 * nm)
print(my_sample.treeToString())
return my_sample
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
