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 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 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 create_diffuse_layout(particle_material, average_layer_thickness):
"""
Createss layout with mesocrystal collection.
"""
m_radius = 5.02
m_nparticles = 100
m_sigma = 0.5
m_diffuse_surface_density = 1e-2
layout = ba.ParticleLayout()
distr = ba.DistributionGaussian(m_radius, m_sigma)
# scale_param = math.sqrt(math.log((m_sigma / m_radius) ** 2 + 1.0))
# distr = ba.DistributionLogNormal(m_radius, scale_param)
particle = ba.Particle(particle_material,
ba.FormFactorFullSphere(m_radius))
sigma_factor = 3.0
par_distr = ba.ParameterDistribution("/Particle/FullSphere/Radius", distr,
m_nparticles, sigma_factor)
part_coll = ba.ParticleDistribution(particle, par_distr)
layout.addParticle(part_coll, 1.0,
ba.kvector_t(0, 0, -average_layer_thickness + 10))
layout.setTotalParticleSurfaceDensity(m_diffuse_surface_density)
return layout
def get_simulation():
"""
Returns a GISAXS simulation with beam (+ divergence) and detector defined.
"""
simulation = ba.GISASSimulation()
simulation.setDetectorParameters(100, 0.0 * deg, 2.0 * deg, 100, 0.0 * deg,
2.0 * deg)
simulation.setBeamParameters(1.0 * angstrom, 0.2 * deg, 0.0 * deg)
wavelength_distr = ba.DistributionLogNormal(1.0 * angstrom, 0.1)
alpha_distr = ba.DistributionGaussian(0.2 * deg, 0.1 * deg)
phi_distr = ba.DistributionGaussian(0.0 * deg, 0.1 * deg)
simulation.addParameterDistribution("*/Beam/Wavelength", wavelength_distr,
5)
simulation.addParameterDistribution("*/Beam/InclinationAngle", alpha_distr,
5)
simulation.addParameterDistribution("*/Beam/AzimuthalAngle", phi_distr, 5)
return simulation
def get_simulation():
"""
Returns a specular simulation with beam and detector defined.
"""
# First argument of ba.DistributionGaussian is
# the mean value for distribution.
# It should be zero in the case of incident angle distribution,
# otherwise an exception is thrown.
alpha_distr = ba.DistributionGaussian(0.0, d_ang)
wavelength_distr = ba.DistributionGaussian(wavelength, d_wl)
simulation = ba.SpecularSimulation()
simulation.setBeamParameters(wavelength, n_bins, alpha_i_min, alpha_i_max)
simulation.addParameterDistribution("*/Beam/InclinationAngle", alpha_distr,
n_points, n_sig)
simulation.addParameterDistribution("*/Beam/Wavelength", wavelength_distr,
n_points, n_sig)
return simulation
def add_beam_divergence(simulation, wavelength):
"""
Adds beam divergence to the simulation
"""
# beam divergence parameters
d_wl = 0.01 * wavelength # spread width for wavelength
d_ang = 0.01 * ba.deg # spread width for incident angle
n_sig = 3 # number of standard deviations to take into account
n_points = 25 # number of points to take in parameter distribution
# creating beam parameter distributions
alpha_distr = ba.DistributionGaussian(0.0, d_ang)
wavelength_distr = ba.DistributionGaussian(wavelength, d_wl)
# adding distributions to the simulation
simulation.addParameterDistribution("*/Beam/InclinationAngle", alpha_distr,
n_points, n_sig)
simulation.addParameterDistribution("*/Beam/Wavelength", wavelength_distr,
n_points, n_sig)
def getSimulation():
simulation = ba.GISASSimulation()
simulation.setDetectorParameters(200, -2.0 * deg, 2.0 * deg, 200,
0.0 * deg, 2.0 * deg)
simulation.setBeamParameters(0.154 * nm, 0.2 * deg, 0.0 * deg)
simulation.setBeamIntensity(1.0e+08)
distribution_1 = ba.DistributionGaussian(0.00349065850399,
0.00174532925199)
simulation.addParameterDistribution("*/Beam/InclinationAngle",
distribution_1, 10, 2.0)
return simulation
def get_simulation():
"""
Returns a depth-probe simulation.
"""
alpha_distr = ba.DistributionGaussian(0.0, d_ang)
footprint = ba.FootprintFactorSquare(beam_sample_ratio)
simulation = ba.DepthProbeSimulation()
simulation.setBeamParameters(wl, n_ai_bins, ai_min, ai_max, footprint)
simulation.setZSpan(n_z_bins, z_min, z_max)
simulation.addParameterDistribution("*/Beam/InclinationAngle", alpha_distr,
n_points, n_sig)
return simulation
def get_simulation():
"""
Returns a depth-probe simulation.
"""
footprint = ba.FootprintFactorSquare(beam_sample_ratio)
simulation = ba.DepthProbeSimulation()
simulation.setBeamParameters(wl, n_ai_bins, ai_min, ai_max, footprint)
simulation.setZSpan(n_z_bins, z_min, z_max)
fwhm2sigma = 2 * np.sqrt(2 * np.log(2))
# add angular beam divergence
alpha_distr = ba.DistributionGaussian(0.0, d_ang / fwhm2sigma)
simulation.addParameterDistribution("*/Beam/InclinationAngle", alpha_distr,
n_points, n_sig)
# add wavelength divergence
wl_distr = ba.DistributionGaussian(wl, d_wl / fwhm2sigma)
simulation.addParameterDistribution("*/Beam/Wavelength", wl_distr,
n_points_wl, n_sig_wl)
return simulation
def create_simulation(arg_dict, bin_start, bin_end):
"""
Creates and returns specular simulation
"""
simulation = ba.SpecularSimulation()
alpha_distr = ba.DistributionGaussian(0.0, arg_dict["divergence"])
footprint = ba.FootprintFactorGaussian(arg_dict["footprint_factor"])
simulation.setBeamParameters(1.54 * ba.angstrom,
get_real_data_axis(bin_start, bin_end),
footprint)
simulation.setBeamIntensity(arg_dict["intensity"])
simulation.addParameterDistribution("*/Beam/InclinationAngle", alpha_distr,
30, 3)
return simulation
def get_simulation():
"""
Create and return GISAXS simulation with beam and detector defined
"""
simulation = ba.GISASSimulation()
simulation.setDetectorParameters(200, -1.0 * deg, 1.0 * deg, 200,
0.0 * deg, 1.0 * deg)
simulation.setBeamParameters(1.0 * angstrom, 0.2 * deg, 0.0 * deg)
# add rotational distribution for lattice
xi_distr = ba.DistributionGaussian(60.0 * deg, 30.0 * deg / 2.355)
simulation.addParameterDistribution("*/Xi", xi_distr, 10, 4)
return simulation
def get_simulation(ai=0.56, u0=45.3, v0=29.9):
"""
Returns a GISAXS simulation with beam and detector defined
wavelength 12.8 angstrom
incident angle 0.0 degrees (transmission)
"""
simulation = ba.GISASSimulation()
simulation.setBeamParameters(12.8 * ba.angstrom, ai * ba.deg, 0.0 * ba.deg)
simulation.setDetector(get_kws3_detector(u0, v0))
simulation.setDetectorResolutionFunction(
ba.ResolutionFunction2DGaussian(5.0, 5.0))
simulation.setBeamIntensity(1000)
distr_1 = ba.DistributionGaussian(1.28 * ba.nm, 0.1)
simulation.addParameterDistribution("*/Beam/Wavelength", distr_1, 50, 2.0,
ba.RealLimits.positive())
simulation.getOptions().setIncludeSpecular(True)
return simulation
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():
"""
Return a sample with cylinders on a substrate.
The cylinders have a Gaussian size distribution.
"""
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# cylindrical particle
radius = 5 * nm
height = radius
cylinder_ff = ba.FormFactorCylinder(radius, height)
cylinder = ba.Particle(m_particle, cylinder_ff)
# collection of particles with size distribution
nparticles = 100
sigma = 0.2 * radius
gauss_distr = ba.DistributionGaussian(radius, sigma)
sigma_factor = 2.0
par_distr = ba.ParameterDistribution("/Particle/Cylinder/Radius",
gauss_distr, nparticles, sigma_factor)
# by uncommenting the line below, the height of the cylinders
# can be scaled proportionally to the radius:
# par_distr.linkParameter("/Particle/Cylinder/Height")
part_coll = ba.ParticleDistribution(cylinder, par_distr)
# assembling the sample
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(part_coll)
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
"""
# 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
