Hexagonal Lattices with Basis

Scattering from two layers of spheres distributed along a hexagonal close packed structure.

  • The sample is made of spherical particles deposited on a substrate.
  • These 10-nanometer-radius particles are distributed along a hexagonal close packed structure:
    • each layer is generated using a two-dimensional hexagonal lattice with a lattice length of 20 nm and its a-axis parallel to the x-axis of the reference cartesian frame.
    • the vertical stacking is done by specifying the position of a "seeding" particle for each layer:

        (0,0,0) for the first layer and (R,R,√3 R) for the second layer, R being the radius of the spherical particle.

    • The wavelength is equal to 1 Å.
    • The incident angles are αi = 0.2° and Φi = 0°.

    Real-space model: 
    Intensity Image: 
    Python Script: 
    """
    Spheres on two hexagonal close packed layers
    """
    import numpy
    import bornagain as ba
    from bornagain import deg, angstrom, nm
    
    phi_min, phi_max = -1.0, 1.0
    alpha_min, alpha_max = 0.0, 1.0
    
    
    def get_sample():
        """
        Returns a sample with spheres on a substrate,
        forming two hexagonal close packed layers.
        """
        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)
    
        radius = 10.0*nm
        sphere_ff = ba.FormFactorFullSphere(radius)
        sphere = ba.Particle(m_particle, sphere_ff)
        particle_layout = ba.ParticleLayout()
    
        pos0 = ba.kvector_t(0.0, 0.0, 0.0)
        pos1 = ba.kvector_t(radius, radius, numpy.sqrt(3.0)*radius)
        basis = ba.ParticleComposition()
        basis.addParticles(sphere, [pos0, pos1])
        particle_layout.addParticle(basis)
    
        interference = ba.InterferenceFunction2DLattice.createHexagonal(radius*2.0)
        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_simulation():
        """
        Returns a GISAXS simulation with beam and detector defined.
        """
        simulation = ba.GISASSimulation()
        simulation.setDetectorParameters(200, phi_min*deg, phi_max*deg,
                                         200, alpha_min*deg, alpha_max*deg)
        simulation.setBeamParameters(1.0*angstrom, 0.2*deg, 0.0*deg)
        return simulation
    
    
    def run_simulation():
        """
        Runs simulation and returns intensity map.
        """
        sample = get_sample()
        simulation = get_simulation()
        simulation.setSample(sample)
        simulation.runSimulation()
        return simulation.getIntensityData()
    
    
    if __name__ == '__main__':
        result = run_simulation()
        ba.plot_intensity_data(result)