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