roi_and_units.py

pospelov, 04 Apr 2018 10:01

Download (4.28 KB)

 
1
"""
2
Simulation with rectangular detector. Pilatus3-1M detector is used as an example.
3
Results will be compared against simulation with spherical detector.
4
"""
5
import numpy
6
import bornagain as ba
7
from bornagain import deg, angstrom, nm
8
import matplotlib
9
from matplotlib import pyplot as plt
10

    
11
detector_distance = 1000.0  # in mm
12
pilatus_pixel_size = 0.172  # in mm
13
pilatus_npx, pilatus_npy = 981, 1043  # number of pixels
14

    
15

    
16
def get_sample():
17
    """
18
    Returns a sample with cylindrical particles on a substrate.
19
    """
20
    # defining materials
21
    m_ambience = ba.HomogeneousMaterial("Air", 0.0, 0.0)
22
    m_substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-8)
23
    m_particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-8)
24

    
25
    # collection of particles
26
    edge = 40*nm
27
    ff = ba.FormFactorBox(edge, edge, edge)
28
    cylinder = ba.Particle(m_particle, ff)
29
    particle_layout = ba.ParticleLayout()
30
    particle_layout.addParticle(cylinder, 1.0)
31

    
32
    air_layer = ba.Layer(m_ambience)
33
    air_layer.addLayout(particle_layout)
34
    substrate_layer = ba.Layer(m_substrate)
35

    
36
    multi_layer = ba.MultiLayer()
37
    multi_layer.addLayer(air_layer)
38
    multi_layer.addLayer(substrate_layer)
39
    return multi_layer
40

    
41

    
42
def get_spherical_detector():
43
    """
44
    Returns a spherical detector roughly approximating our PILATUS detector
45
    """
46
    n_phi = pilatus_npx
47
    n_alpha = pilatus_npy
48
    width = pilatus_npx*pilatus_pixel_size
49
    height = pilatus_npy*pilatus_pixel_size
50
    phi_min = numpy.arctan(-width/2./detector_distance)
51
    phi_max = numpy.arctan(width/2./detector_distance)
52
    alpha_min = 0.0
53
    alpha_max = numpy.arctan(height/detector_distance)
54
    return ba.SphericalDetector(
55
        n_phi, phi_min, phi_max, n_alpha, alpha_min, alpha_max)
56

    
57

    
58
def get_rectangular_detector():
59
    """
60
    Returns a rectangular detector representing our PILATUS detector
61
    """
62
    width = pilatus_npx*pilatus_pixel_size
63
    height = pilatus_npy*pilatus_pixel_size
64
    detector = ba.RectangularDetector(pilatus_npx, width, pilatus_npy, height)
65
    detector.setPerpendicularToSampleX(detector_distance, width/2., 0.0)
66
    return detector
67

    
68

    
69
def get_simulation():
70
    """
71
    Return a GISAXS simulation with defined beam
72
    """
73
    simulation = ba.GISASSimulation()
74
    simulation.setBeamParameters(10*angstrom, 0.2*deg, 0.0*deg)
75
    return simulation
76

    
77

    
78
def plot(results):
79
    """
80
    Plots results of two simulations and their relative difference on one canvas
81
    """
82
    from matplotlib import colors
83
    fig = plt.figure(figsize=(13.6, 10.6))
84

    
85
    # showing  result of spherical detector simulation
86
    plt.subplot(2, 3, 1)
87
    ba.plot_colormap(results['spherical'], title="SphDet",
88
                     zlabel="")
89

    
90
    # showing  result of rectangular detector simulation
91
    plt.subplot(2, 3, 2)
92
    ba.plot_colormap(results['rectangular'], title="RectDect",
93
                     zlabel="")
94

    
95
    # rectangular detector results with DEG as units
96
    plt.subplot(2, 3, 3)
97
    ba.plot_colormap(results['rectangular'], units=ba.AxesUnits.DEGREES, title="RectDect in DEGREES",
98
                     zlabel="")
99

    
100
    # rectangular detector results with ROI
101
    plt.subplot(2, 3, 4)
102
    ba.plot_colormap(results['rec_roi'], title="RectDet + ROI",
103
                     zlabel="")
104

    
105
    plt.subplot(2, 3, 5)
106
    ba.plot_colormap(results['rec_roi'], units=ba.AxesUnits.DEGREES, title="RectDet + ROI in DEGREES",
107
                     zlabel="")
108

    
109
    plt.subplots_adjust(left=0.05, right=0.92, top=0.88, bottom=0.12)
110
    plt.tight_layout()
111

    
112
    plt.show()
113

    
114

    
115
def run_simulation():
116
    """
117
    Run two simulations for two different detectors and plot results
118
    """
119
    results = {}
120

    
121
    sample = get_sample()
122
    simulation = get_simulation()
123
    simulation.setSample(sample)
124

    
125
    # runs simulation for spherical detector
126
    simulation.setDetector(get_spherical_detector())
127
    simulation.runSimulation()
128
    results['spherical'] = simulation.result()
129

    
130
    # runs simulation for rectangular detector
131
    simulation.setDetector(get_rectangular_detector())
132
    simulation.runSimulation()
133
    results['rectangular'] = simulation.result()
134

    
135
    # setting ROI
136
    simulation.setRegionOfInterest(80.0, 10.0, 120.0, 30.0)
137
    simulation.runSimulation()
138
    results['rec_roi'] = simulation.result()
139

    
140

    
141
    return results
142

    
143

    
144
if __name__ == '__main__':
145
    results = run_simulation()
146
    plot(results)