# Rectangular grating

In this example we simulate the scattering from infinite 1D repetition of rectangular patches (rectangular grating). This is done by using the interference function of a 1D lattice together with very long boxes. While being similar to  Interference 1D lattice example, this example explains the lattice orientation in more details.

• By-default, the axis of the one-dimensional lattice coincides with the x-axis of the reference cartesian frame, so it coinsides with the beam direction.
• Long boxes are placed along a one-dimensional lattice on top of substrate, the lattice_length parameter corresponds to the grating period.
• The size of boxes is initially chosen to form a grating which is perpendicular to the beam (long side of the box is along y-axis).
• Please keep in mind, that `length, width, height` in the `FormFactorBox(length, width, height)` constructor correspond to the directions in the `x,y,z` axes, in that order, so to achieve the desired setup we use the values: length=10nm, width=10000nm, height=10nm.
• The whole grating is rotated at the end by an angle of 45 degrees with respect to the beam axis. This is achieved by rotating both the 1D lattice and the long boxes (lines 25 and 34).
• To avoid the problem of rapidly oscillating form factors of long boxes (see this example for more details), the simulation is performed in monte carlo integration mode.
Real-space model:
Intensity Image:
Python Script:
```"""
Simulation of grating using very long boxes and 1D lattice.
Monte-carlo integration is used to get rid of
large-particle form factor oscillations.
"""
import bornagain as ba
from bornagain import deg, angstrom, nm

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()
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)
substrate_layer = ba.Layer(m_substrate)

multi_layer = ba.MultiLayer()
return multi_layer

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, 2.0*deg)
simulation.setBeamParameters(1.0*angstrom, 0.2*deg, 0.0*deg)
simulation.getOptions().setMonteCarloIntegration(True, 100)
return simulation

def run_simulation():
"""
Runs simulation and returns intensity map.
"""
simulation = get_simulation()
simulation.setSample(get_sample())
simulation.setTerminalProgressMonitor()
simulation.runSimulation()
return simulation.getIntensityData()

if __name__ == '__main__':
result = run_simulation()
ba.plot_intensity_data(result)

```