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