def get_sample():
"""
Returns a sample with cylinders of two different sizes on a substrate.
The cylinder positions are modelled in Size-Spacing Coupling 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 function
interference = ba.InterferenceFunctionRadialParaCrystal(
18.0 * nm, 1e3 * nm)
pdf = ba.FTDistribution1DGauss(3 * nm)
interference.setProbabilityDistribution(pdf)
interference.setKappa(1.0)
# assembling the sample
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder1, 0.8)
particle_layout.addParticle(cylinder2, 0.2)
particle_layout.setInterferenceFunction(interference)
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():
# 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.0001)
# 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.addLayer(layer_2)
# multiLayer_1.addLayerWithTopRoughness(layer_2, layerRoughness_1)
return multiLayer_1
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 get_sample():
"""
Constructs a sample with one resonating Ti/Pt layer
"""
# define materials
m_Si = ba.HomogeneousMaterial("Si", 3.3009e-05, 0.0)
m_Ti = ba.HomogeneousMaterial("Ti", -3.0637e-05, 1.5278e-08)
m_TiO2 = ba.HomogeneousMaterial("TiO2", 4.1921e-05, 8.1293e-09)
m_Pt = ba.HomogeneousMaterial("Pt", 1.0117e-04, 3.01822e-08)
m_D2O = ba.HomogeneousMaterial("D2O", 1.0116e-04, 1.8090e-12)
# create layers
l_Si = ba.Layer(m_Si)
l_Ti = ba.Layer(m_Ti, 130.0 * angstrom)
l_Pt = ba.Layer(m_Pt, 320.0 * angstrom)
l_Ti_top = ba.Layer(m_Ti, 100.0 * angstrom)
l_TiO2 = ba.Layer(m_TiO2, 30.0 * angstrom)
l_D2O = ba.Layer(m_D2O)
# construct sample
sample = ba.MultiLayer()
sample.addLayer(l_Si)
sample.addLayer(l_Ti)
sample.addLayer(l_Pt)
sample.addLayer(l_Ti_top)
sample.addLayer(l_TiO2)
sample.addLayer(l_D2O)
return sample
def get_sample():
"""
Constructs a sample with one resonating Ti/Pt layer
"""
# define materials
m_Si = ba.MaterialBySLD("Si", 2.07e-06, 2.38e-11)
m_Ti = ba.MaterialBySLD("Ti", 2.8e-06, 5.75e-10)
m_Pt = ba.MaterialBySLD("Pt", 6.36e-06, 1.9e-09)
m_TiO2 = ba.MaterialBySLD("TiO2", 2.63e-06, 5.4e-10)
m_D2O = ba.MaterialBySLD("D2O", 6.34e-06, 1.13e-13)
# create layers
l_Si = ba.Layer(m_Si)
l_Ti = ba.Layer(m_Ti, 130.0 * angstrom)
l_Pt = ba.Layer(m_Pt, 320.0 * angstrom)
l_Ti_top = ba.Layer(m_Ti, 100.0 * angstrom)
l_TiO2 = ba.Layer(m_TiO2, 30.0 * angstrom)
l_D2O = ba.Layer(m_D2O)
# construct sample
sample = ba.MultiLayer()
sample.addLayer(l_Si)
# put your code here (1 line), take care of correct indents
sample.addLayer(l_Ti)
sample.addLayer(l_Pt)
sample.addLayer(l_Ti_top)
sample.addLayer(l_TiO2)
sample.addLayer(l_D2O)
return sample
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():
# 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(radius=5.0 * nm, height=10.0 * nm):
"""
Build the sample representing cylinders on top of substrate without interference.
"""
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)
cylinder_ff = ba.FormFactorCylinder(radius, height)
cylinder = ba.Particle(m_particle, cylinder_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder)
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(radius=5.0 * nm, height=10.0 * nm):
"""
Returns a sample with uncorrelated cylinders on a substrate.
"""
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)
cylinder_ff = ba.FormFactorCylinder(radius, height)
cylinder = ba.Particle(m_particle, cylinder_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder)
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(self, particle_to_air=None, particle_to_substrate=None):
"""
Helper function returning a multilayer (air, substrate) using particles provided
by the user.
"""
vacuum_layer = ba.Layer(mAmbience)
if particle_to_air:
layout = ba.ParticleLayout()
layout.addParticle(particle_to_air)
vacuum_layer.addLayout(layout)
substrate = ba.Layer(mSubstrate)
if particle_to_substrate:
layout = ba.ParticleLayout()
layout.addParticle(particle_to_substrate)
substrate.addLayout(layout)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(vacuum_layer)
multi_layer.addLayer(substrate)
return multi_layer
def get_sample():
# Defining Materials
material_1 = ba.HomogeneousMaterial("Air", 0.0, 0.0)
material_2 = ba.HomogeneousMaterial("CoFe2O4", 2.0433e-05, 1.5253e-06)
material_3 = ba.HomogeneousMaterial("SiO2", 5.43852457e-06, 5.43741763e-08)
material_4 = ba.HomogeneousMaterial("Si", 5.78164999998e-06, 1.02295e-07)
# Defining Layers
layer_1 = ba.Layer(material_1)
layer_2 = ba.Layer(material_3, 60)
layer_3 = ba.Layer(material_4)
# Defining Form Factors
formFactor_1 = ba.FormFactorTruncatedSphere(10.0 * nm, 8.5 * nm, 0.0 * nm)
#formFactor_1 = ba.FormFactorFullSphere(10.0 * nm)
# Defining Particles
particle_1 = ba.Particle(material_2, formFactor_1)
# Defining Interference Functions
interference_1 = ba.InterferenceFunction2DLattice(34.0 * nm, 34.0 * nm, 120.0 * deg, 0.0 * deg)
interference_1_pdf = ba.FTDecayFunction2DCauchy(300.0 * nm, 100.0 * nm, 0.0 * deg)
interference_1.setDecayFunction(interference_1_pdf)
# Defining Particle Layouts and adding Particles
layout_1 = ba.ParticleLayout()
layout_1.addParticle(particle_1, 1.0)
layout_1.setInterferenceFunction(interference_1)
layout_1.setTotalParticleSurfaceDensity(0.000998875898252)
# 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)
multiLayer_1.addLayer(layer_3)
return multiLayer_1
def get_sample(radius_a=4.0*nm, radius_b=4.0*nm, height=4.0*nm):
"""
Returns a sample with uncorrelated cylinders and pyramids.
"""
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)
formFactor = ba.FormFactorHemiEllipsoid(radius_a, radius_b, height)
hemiEllipsoid = ba.Particle(m_particle, formFactor)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(hemiEllipsoid)
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):
# Defining Materials
material_1 = ba.MaterialBySLD("Air", 0.0, 0.0)
material_2 = ba.MaterialBySLD("AgNano", params["Ag_dens_f"] * 1.322e-06,
params["Ag_dens_f"] * 4.85e-07)
material_3 = ba.MaterialBySLD("SiO2", params["SiO_dens_f"] * 3.681e-06,
params["SiO_dens_f"] * 5.43e-07)
material_4 = ba.MaterialBySLD("Si", 2.074e-06, 6.3e-08)
# Defining Layers
layer_1 = ba.Layer(material_1)
layer_2 = ba.Layer(material_2, params["Ag_thick"])
layer_3 = ba.Layer(material_3, params["SiO_thick"])
layer_4 = ba.Layer(material_4)
# Defining Multilayers
multiLayer_1 = ba.MultiLayer()
multiLayer_1.addLayer(layer_1)
multiLayer_1.addLayer(layer_2)
multiLayer_1.addLayer(layer_3)
multiLayer_1.addLayer(layer_4)
return multiLayer_1
def get_sample(params):
"""
Creates a sample and returns it
:param params: a dictionary of optimization parameters
:return: the sample defined
"""
# substrate (Si)
si_sld_real = 2.0704e-06 # \AA^{-2}
density_si = 0.0499 / ba.angstrom**3 # Si atomic number density
# layers' parameters
n_repetitions = 10
# Ni
ni_sld_real = 9.4245e-06 # \AA^{-2}
ni_thickness = 70 * ba.angstrom
# Ti
ti_sld_real = -1.9493e-06 # \AA^{-2}
ti_thickness = params["ti_thickness"]
# defining materials
m_vacuum = ba.MaterialBySLD()
m_ni = ba.MaterialBySLD("Ni", ni_sld_real, 0.0)
m_ti = ba.MaterialBySLD("Ti", ti_sld_real, 0.0)
m_substrate = ba.MaterialBySLD("SiSubstrate", si_sld_real, 0.0)
# vacuum layer and substrate form multi layer
vacuum_layer = ba.Layer(m_vacuum)
ni_layer = ba.Layer(m_ni, ni_thickness)
ti_layer = ba.Layer(m_ti, ti_thickness)
substrate_layer = ba.Layer(m_substrate)
multi_layer = ba.MultiLayer()
multi_layer.addLayer(vacuum_layer)
for i in range(n_repetitions):
multi_layer.addLayer(ti_layer)
multi_layer.addLayer(ni_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
def get_sample():
"""
define sample with Si box nanodots in a square lattice
:return: sample
"""
# Defining Materials
m_air = ba.HomogeneousMaterial("Air", 0.0, 0.0)
m_si = ba.HomogeneousMaterial("Si", 7.6e-06, 1.7e-07)
# Defining Layers
l_air = ba.Layer(m_air)
l_si = ba.Layer(m_si)
# Defining Form Factor
ff = ba.FormFactorBox(20.0 * nm, 20.0 * nm, 20.0 * nm)
# Defining Particles
particle = ba.Particle(m_si, ff)
# Defining Interference Function
interference = ba.InterferenceFunction2DLattice.createSquare(
45.0 * nm, 45 * deg)
pdf = ba.FTDecayFunction2DCauchy(1000.0 * nm, 1000.0 * nm)
interference.setDecayFunction(pdf)
# Defining Particle Layout and adding Particles
layout = ba.ParticleLayout()
layout.addParticle(particle, 1.0)
layout.addInterferenceFunction(interference)
# Adding layout to layer
l_air.addLayout(layout)
# Defining Multilayer
multi_layer = ba.MultiLayer()
multi_layer.addLayer(l_air)
multi_layer.addLayer(l_si)
return multi_layer
def build_sample(self):
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(self.radius)
sphere = ba.Particle(m_particle, sphere_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(sphere)
interference = ba.InterferenceFunction2DLattice.createHexagonal(self.lattice_length)
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 particles, having a custom form factor, on 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
ff = CustomFormFactor(20.0 * nm, 15.0 * nm)
particle = ba.Particle(m_particle, ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(particle, 1.0)
air_layer = ba.Layer(m_ambience)
air_layer.addLayout(particle_layout)
substrate_layer = ba.Layer(m_substrate)
# assemble multilayer
multi_layer = ba.MultiLayer()
multi_layer.addLayer(air_layer)
multi_layer.addLayer(substrate_layer)
return multi_layer
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():
"""
Returns a sample with uncorrelated cylinders 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)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder, 1.0)
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(cylinder_radius, cylinder_height):
"""
Returns a sample with cylindrical particles on 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
cylinder_ff = ba.FormFactorCylinder(cylinder_radius, cylinder_height)
cylinder = ba.Particle(m_particle, cylinder_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder, 1.0)
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():
# 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():
"""
Returns a sample with cylinders on a substrate,
forming a 2D centered 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.InterferenceFunction2DLattice.createSquare(25.0*nm)
pdf = ba.FTDecayFunction2DCauchy(300.0*nm/2.0/numpy.pi,
100.0*nm/2.0/numpy.pi)
interference.setDecayFunction(pdf)
particle_layout = ba.ParticleLayout()
position1 = ba.kvector_t(0.0, 0.0, 0.0)
position2 = ba.kvector_t(12.5*nm, 12.5*nm, 0.0)
cylinder_ff = ba.FormFactorCylinder(3.*nm, 3.*nm)
cylinder = ba.Particle(m_particle, cylinder_ff)
basis = ba.ParticleComposition()
basis.addParticles(cylinder, [position1, position2])
particle_layout.addParticle(basis)
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 a cylindrically shaped mesocrystal on 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)
# mesocrystal lattice
lattice_basis_1 = ba.kvector_t(5.0, 0.0, 0.0)
lattice_basis_2 = ba.kvector_t(0.0, 5.0, 0.0)
lattice_basis_3 = ba.kvector_t(0.0, 0.0, 5.0)
lattice = ba.Lattice(lattice_basis_1, lattice_basis_2, lattice_basis_3)
# spherical particle that forms the base of the mesocrystal
sphere_ff = ba.FormFactorFullSphere(2 * nm)
sphere = ba.Particle(m_particle, sphere_ff)
# crystal structure
crystal = ba.Crystal(sphere, lattice)
# mesocrystal
meso_ff = ba.FormFactorCylinder(20 * nm, 50 * nm)
meso = ba.MesoCrystal(crystal, meso_ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(meso)
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 two layers on a substrate, with correlated roughnesses.
"""
# defining materials
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)
# defining layers
l_ambience = ba.Layer(m_ambience)
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 with cylindrical particles 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
edge = 40 * nm
ff = ba.FormFactorBox(edge, edge, edge)
cylinder = ba.Particle(m_particle, ff)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder, 1.0)
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 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(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 get_sample(formfactor):
"""
Returns a one-layer sample that contains particles with given form factor.
"""
# defining materials
m_vacuum = ba.HomogeneousMaterial("Vacuum", 0.0, 0.0)
m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
# collection of particles
particle = ba.Particle(m_particle, formfactor)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(particle, 1.0)
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 cylinders in a homogeneous environment ("air"),
implying a simulation in plain Born approximation.
"""
# defining materials
m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
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)
particle_layout = ba.ParticleLayout()
particle_layout.addParticle(cylinder, 1.0)
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_simulation(params):
"""
Returns GISAS simulation for given set of parameters.
"""
radius = params["radius"]
sphere = ba.Particle(ba.HomogeneousMaterial("Particle", 6e-4, 2e-8),
ba.FormFactorFullSphere(radius))
layer = ba.Layer(ba.HomogeneousMaterial("Air", 0.0, 0.0))
layer.addLayout(ba.ParticleLayout(sphere))
multi_layer = ba.MultiLayer()
multi_layer.addLayer(layer)
simulation = ba.GISASSimulation()
simulation.setDetectorParameters(100, -1.0 * deg, 1.0 * deg, 100,
0.0 * deg, 2.0 * deg)
simulation.setBeamParameters(1.0 * angstrom, 0.2 * deg, 0.0 * deg)
simulation.setSample(multi_layer)
return simulation
