예제 #1
0
    def generate_pattern(self,
                         pattern_size_pixels=1024,
                         detector_distance=740e-3,
                         detector_pixel_size=75e-6,
                         wavelength=conversions.ev_to_m(1100),
                         number_of_scattered_photons=1e9):

        #Method for simulating a diffraction pattern, based on generate_single.py by Tomas Ekeberg. Wavelength in meters.

        # Small angle approximation
        max_scattering_angle = pattern_size_pixels * detector_pixel_size / (
            2 * detector_distance)
        real_space_pixel_size = wavelength / (max_scattering_angle * 2)
        # Sample is self
        real_space = np.zeros((pattern_size_pixels, ) * 2)
        support = tools.circular_mask(pattern_size_pixels,
                                      self.particle_size / 2)

        # Use FFT to simulate diffraction pattern
        tools.insert_array_at_center(real_space, self.particle.sum(axis=0))
        diffracted_wave = np.fft.fftshift(
            np.fft.fft2(np.fft.fftshift(real_space)))
        rescale_factor = np.sqrt(number_of_scattered_photons /
                                 (abs(diffracted_wave)**2).sum())
        diffracted_wave *= rescale_factor
        real_space *= rescale_factor

        detected_intensity = np.random.poisson(abs(diffracted_wave)**2)

        #Utput
        return detected_intensity, diffracted_wave, support
예제 #2
0
import numpy as np
import spimage
import matplotlib.pyplot as plt
"""
1. Create the particle
2. Generate the diffraction pattern
3. Multiple phase retrieveal (PRTF)
4. Output relevant data (What data is relevant?)

This should happen for each particle, with parameters size and photon intensity (logrange)( Feature size?).
"""
#Setup values
pattern_size_pixels = 1024
detector_distance = 740e-3
detector_pixel_size = 75e-6
wavelength = conversions.ev_to_m(1100)

#Iteration process
f_len = int(3)
p_len = int(3)
np_len = int(3)
index = int(os.environ["SLURM_ARRAY_TASK_ID"])

ps1 = np.linspace(20, 200, p_len)
a = np.zeros((f_len, p_len, np_len))
ps3 = ps1[np.newaxis, :, np.newaxis] + a
particle_size = int(ps3.flatten()[index])

fs1 = np.linspace(particle_size / 10, particle_size / 5, f_len)
fs3 = fs1[:, np.newaxis, np.newaxis] + a
feature_size = int(fs3.flatten()[index])
# Class for generating an Elser Particle for testing diffraction patterns
# Takes inputs for particle and detector in SI units
# By Vidar Elsin, based on generate_single by Tomas Ekeberg and classes.py by August Wolter

from eke import elser_particles
from eke import conversions
from eke import tools
import numpy as np

# SETUP AND DETECTOR SETTINGS

pattern_size_pixels = 1024
detector_distance = 400.e-3
detector_pixel_size = 75e-6
wavelength = conversions.ev_to_m(1100)  # ca 1.127 nm
#number_of_photons = 2.5e6
number_of_photons = 1e9  #high
#number_of_photons = 2.5e4 #low

# Small angle approximation
max_scattering_angle = (pattern_size_pixels *
                        detector_pixel_size) / (2 * detector_distance)
real_space_pixel_size = wavelength / max_scattering_angle

settings = {
    'pattern_size_pixels': pattern_size_pixels,
    'detector_distance': detector_distance,
    'detector_pixel_size': detector_pixel_size,
    'wavelength': wavelength,
    'number_of_photons': number_of_photons,
    'real_space_pixel_size': real_space_pixel_size,