def test_map_interpolation(tolerance=0.1):
import logging
logger = logging.getLogger("condor")
logger.setLevel("DEBUG")
src = condor.Source(wavelength=10.0E-9,
pulse_energy=1E-3,
focus_diameter=1E-6)
det = condor.Detector(distance=1.0, pixel_size=300E-6, nx=256, ny=256)
par = condor.ParticleMap(diameter=600E-9,
material_type="cell",
geometry="custom",
map3d_filename=here + "/examples/map3d.h5",
map3d_dataset="data",
dx=5E-9)
s = "particle_map"
E = condor.Experiment(src, {s: par}, det)
res0 = E.propagate()
I0 = res0["entry_1"]["data_1"]["data"]
# Now without interpolation
print "NOW WITHOUT INTERPOLATION"
condor.particle.particle_map.ENABLE_MAP_INTERPOLATION = False
src = condor.Source(wavelength=10.0E-9,
pulse_energy=1E-3,
focus_diameter=1E-6)
det = condor.Detector(distance=1.0, pixel_size=300E-6, nx=256, ny=256)
par = condor.ParticleMap(diameter=600E-9,
material_type="cell",
geometry="custom",
map3d_filename=here + "/examples/map3d.h5",
map3d_dataset="data",
dx=5E-9)
s = "particle_map"
E = condor.Experiment(src, {s: par}, det)
res1 = E.propagate()
I1 = res1["entry_1"]["data_1"]["data"]
import matplotlib.pyplot as pypl
pypl.imsave("./Imap_interp.png", abs(I0), vmin=0, vmax=I0.max())
pypl.imsave("./Imap_no_interp.png", abs(I1), vmin=0, vmax=I0.max())
err = abs(I0 - I1).sum() / ((I0 + I1).sum() / 2.)
if err < tolerance:
print "\t=> Test successful (err = %e)" % err
return False
else:
print "\t=> Test failed (err = %e)" % err
return True
import condor
import logging
logger = logging.getLogger("condor")
#logger.setLevel("DEBUG")
#logger.setLevel("WARNING")
logger.setLevel("INFO")
N = 1
rotation_formalism="random"
rotation_values = None
# Source
src = condor.Source(wavelength=0.147E-9, pulse_energy=1E-3, focus_diameter=1E-6)
# Detector
det = condor.Detector(distance=0.9, pixel_size=400E-6, nx=250, ny=250)
# Map
#print("Simulating map")
par = condor.ParticleMap(diameter=None, material_type="poliovirus", geometry="custom",
emd_id="1144",
rotation_formalism=rotation_formalism, rotation_values=rotation_values)
s = "particle_map"
E = condor.Experiment(src, {s : par}, det)
W = condor.utils.cxiwriter.CXIWriter("./condor.cxi")
for i in range(N):
t = time.time()
res = E.propagate()
#print(time.time()-t)
if plotting:
real_space = numpy.fft.fftshift(numpy.fft.ifftn(res["entry_1"]["data_1"]["data_fourier"]))
rotation_values = None
focus_diameter = 100e-9
intensity = 2 * 1.02646137e9
pulse_energy = ((focus_diameter**2) * numpy.pi / 4.) * intensity
wavelength = 0.2262e-9
pixelsize = 110e-6
distance = 2.4
dx = 3.76e-10
# Source
src = condor.Source(wavelength=wavelength,
pulse_energy=pulse_energy,
focus_diameter=focus_diameter)
# Detector
det = condor.Detector(distance=distance, pixel_size=pixelsize, nx=414, ny=414)
# Map
print "Simulating map"
par = condor.ParticleMap(diameter=40E-9,
material_type="poliovirus",
geometry="custom",
map3d_filename="../../map3d.h5",
map3d_dataset="data",
dx=dx,
rotation_formalism=rotation_formalism,
rotation_values=rotation_values)
s = "particle_map"
E = condor.Experiment(src, {s: par}, det)
W = condor.utils.cxiwriter.CXIWriter("./condor.cxi")
for i in range(N):
def calculate(self, structure, **kwargs):
"""Calculate the descriptor for the given ASE structure.
Parameters:
structure: `ase.Atoms` object
Atomic structure.
"""
atoms = scale_structure(
structure,
scaling_type=self.atoms_scaling,
atoms_scaling_cutoffs=self.atoms_scaling_cutoffs)
# Source
src = condor.Source(**self.param_source)
# Detector
det = condor.Detector(**self.param_detector)
# Atoms
atomic_numbers = map(lambda el: el.number, atoms)
atomic_numbers = [
atomic_number + 2 for atomic_number in atomic_numbers
]
# convert Angstrom to m (CONDOR uses meters)
atomic_positions = map(
lambda pos: [pos.x * 1E-10, pos.y * 1E-10, pos.z * 1E-10], atoms)
intensity_rgb = []
rs_rgb = []
ph_rgb = []
real_space = None
phases = None
for [_, rot_matrices] in iteritems(self.rot_matrices):
# loop over channels
intensity_channel = []
rs_channel = []
ph_channel = []
for rot_matrix in rot_matrices:
# loop over the rotation matrices in a given channel
# and sum the intensities in the same channel
quaternion = condor.utils.rotation.quat_from_rotmx(rot_matrix)
rotation_values = np.array([quaternion])
rotation_formalism = 'quaternion'
rotation_mode = 'intrinsic'
par = condor.ParticleAtoms(
atomic_numbers=atomic_numbers,
atomic_positions=atomic_positions,
rotation_values=rotation_values,
rotation_formalism=rotation_formalism,
rotation_mode=rotation_mode)
s = 'particle_atoms'
condor_exp = condor.Experiment(src, {s: par}, det)
res = condor_exp.propagate()
# retrieve results
real_space = np.fft.fftshift(
np.fft.ifftn(
np.fft.fftshift(
res["entry_1"]["data_1"]["data_fourier"])))
intensity = res["entry_1"]["data_1"]["data"]
fourier_space = res["entry_1"]["data_1"]["data_fourier"]
phases = np.angle(fourier_space) % (2 * np.pi)
if self.use_mask:
# set to zero values outside a ring-like mask
xc = (self.n_px - 1.0) / 2.0
yc = (self.n_py - 1.0) / 2.0
n = self.n_px
a, b = xc, yc
x, y = np.ogrid[-a:n - a, -b:n - b]
mask_int = x * x + y * y <= self.mask_r_min * self.mask_r_min
mask_ext = x * x + y * y >= self.mask_r_max * self.mask_r_max
for i in range(self.n_px):
for j in range(self.n_py):
if mask_int[i, j]:
intensity[i, j] = 0.0
if mask_ext[i, j]:
intensity[i, j] = 0.0
intensity_channel.append(intensity)
rs_channel.append(real_space.real)
ph_channel.append(phases)
# first sum the angles within the channel, then normalize
intensity_channel = np.asarray(intensity_channel).sum(axis=0)
rs_channel = np.asarray(rs_channel).sum(axis=0)
ph_channel = np.asarray(ph_channel).sum(axis=0)
# append normalized data from different channels
# and divide by the angles per channel
intensity_rgb.append(intensity_channel)
rs_rgb.append(rs_channel)
ph_rgb.append(ph_channel)
intensity_rgb = np.asarray(intensity_rgb)
intensity_rgb = (intensity_rgb - intensity_rgb.min()) / (
intensity_rgb.max() - intensity_rgb.min())
rs8 = (((real_space.real - real_space.real.min()) /
(real_space.real.max() - real_space.real.min())) *
255.0).astype(np.uint8)
ph8 = (((phases - phases.min()) / (phases.max() - phases.min())) *
255.0).astype(np.uint8)
# reshape to have nb of color channels last
intensity_rgb = intensity_rgb.reshape(intensity_rgb.shape[1],
intensity_rgb.shape[2],
intensity_rgb.shape[0])
# add results in ASE structure info
descriptor_data = dict(descriptor_name=self.name,
descriptor_info=str(self),
diffraction_2d_intensity=intensity_rgb,
diffraction_2d_real_space=rs8,
diffraction_2d_phase=ph8)
structure.info['descriptor'] = descriptor_data
return structure
import numpy
import condor
# Core
atomic_composition_core = {"Xe": 1.}
massdensity_core = 3640.
diameter_core = 50E-9
# Shell
atomic_composition_shell = {"H": 2., "O": 1.}
massdensity_shell = 1000.
thickness_shell = 30E-9
S = condor.Source(wavelength=1E-9, pulse_energy=1E-3, focus_diameter=2E-6)
D = condor.Detector(pixel_size=75E-6, nx=1024, ny=1024, distance=0.15)
# Build 3D map for particle model
dx = 0.25*D.get_resolution_element_x(S.photon.get_wavelength())
N = int(numpy.round((1.2*diameter_core+2*thickness_shell)/dx))
assert (dx*N) > (1.1*diameter_core+2*thickness_shell)
map3d = numpy.zeros(shape=(2,N,N,N))
X,Y,Z = numpy.mgrid[:N,:N,:N]
R = numpy.sqrt((X-(N-1)/2.)**2+(Y-(N-1)/2.)**2+(Z-(N-1)/2.)**2)*dx
(map3d[0])[R <= diameter_core/2.] = 1.
if thickness_shell > dx:
(map3d[1])[(R > diameter_core/2.)*(R <= (diameter_core+thickness_shell*2)/2.)] = 1.
# Initialise particle class instance
P = condor.ParticleMap(geometry='custom',
material_type=['custom','custom'],
dx=dx, map3d=map3d,
if False:
N = 1
extrinsic_quaternion = numpy.array(
[0.05419534, 0.29519801, -0.91633864, 0.26503677])
rotation_formalism = "quaternion"
rotation_values = [extrinsic_quaternion]
else:
N = 2
rotation_formalism = "random"
rotation_values = None
# Source
src = condor.Source(wavelength=1.0E-9, pulse_energy=1E-3, focus_diameter=1E-6)
# Detector
det = condor.Detector(distance=1.0, pixel_size=300E-6, nx=256, ny=256)
# Map
#print "Simulating map"
par = condor.ParticleMap(diameter=600E-9,
material_type="cell",
geometry="custom",
map3d_filename="../../map3d.h5",
map3d_dataset="data",
dx=5E-9,
rotation_formalism=rotation_formalism,
rotation_values=rotation_values)
s = "particle_map"
E = condor.Experiment(src, {s: par}, det)
W = condor.utils.cxiwriter.CXIWriter("./condor.cxi")
for i in range(N):
import os
import condor
this_dir = os.path.dirname(os.path.realpath(__file__))
do_plot = False
if do_plot:
import matplotlib
matplotlib.use('TkAgg')
from matplotlib import pyplot
from matplotlib.colors import LogNorm
src = condor.Source(wavelength=0.1E-10, pulse_energy=1E-3, focus_diameter=1E-6)
ds = 16
det = condor.Detector(distance=2., pixel_size=110E-6*ds, nx=1024/ds+1, ny=1024/ds+1, solid_angle_correction=False)
psphere = {"particle_sphere": condor.ParticleSphere(diameter=1E-9, material_type="water")}
pmap = {"particle_map": condor.ParticleMap(diameter=1E-9, material_type="water", geometry="icosahedron")}
patoms = {"particle_atoms": condor.ParticleAtoms(pdb_filename="%s/../../DNA.pdb" % this_dir)}
particles = [psphere, pmap, patoms]
if do_plot:
fig, (axs1, axs2) = pyplot.subplots(2, len(particles), figsize=(3*len(particles), 3*2))
for i,par in enumerate(particles):
E = condor.Experiment(src, par, det)
res = E.propagate()
data = res["entry_1"]["data_1"]["data"]
if do_plot:
def calculate(self,
structure,
min_nb_atoms=20,
plot_3d=False,
plot_slices=False,
plot_slices_sph_coords=False,
save_diff_intensity=True,
**kwargs):
"""Calculate the descriptor for the given ASE structure.
Parameters:
structure: `ase.Atoms` object
Atomic structure.
min_nb_atoms: int, optional (default=20)
If the structure contains less than ``min_nb_atoms``, the descriptor is not calculated and an array with
zeros is return as descriptor. This is because the descriptor is expected to be no longer meaningful for
such a small amount of atoms present in the chosen structure.
"""
if len(structure) > min_nb_atoms - 1:
atoms = scale_structure(
structure,
scaling_type=self.atoms_scaling,
atoms_scaling_cutoffs=self.atoms_scaling_cutoffs,
extrinsic_scale_factor=self.extrinsic_scale_factor)
# Source
src = condor.Source(**self.param_source)
# Detector
# solid_angle_correction are meaningless for 3d diffraction
det = condor.Detector(solid_angle_correction=False,
**self.param_detector)
# Atoms
atomic_numbers = map(lambda el: el.number, atoms)
atomic_numbers = [
atomic_number + 5 for atomic_number in atomic_numbers
]
# atomic_numbers = [82 for atomic_number in atomic_numbers]
# convert Angstrom to m (CONDOR uses meters)
atomic_positions = map(
lambda pos: [pos.x * 1E-10, pos.y * 1E-10, pos.z * 1E-10],
atoms)
par = condor.ParticleAtoms(atomic_numbers=atomic_numbers,
atomic_positions=atomic_positions)
s = "particle_atoms"
condor_exp = condor.Experiment(src, {s: par}, det)
res = condor_exp.propagate3d()
# retrieve some physical quantities that might be useful for users
intensity = res["entry_1"]["data_1"]["data"]
fourier_space = res["entry_1"]["data_1"]["data_fourier"]
phases = np.angle(fourier_space) % (2 * np.pi)
# 3D diffraction calculation
real_space = np.fft.fftshift(
np.fft.ifftn(
np.fft.fftshift(res["entry_1"]["data_1"]["data_fourier"])))
window = get_window(self.window, self.n_px)
tot_density = window * real_space.real
center_of_mass = ndimage.measurements.center_of_mass(tot_density)
logger.debug("Tot density data dimensions: {}".format(
tot_density.shape))
logger.debug(
"Center of mass of total density: {}".format(center_of_mass))
# take the fourier transform of structure in real_space
fft_coeff = fftpack.fftn(tot_density,
shape=(self.nx_fft, self.ny_fft,
self.nz_fft))
# now shift the quadrants around so that low spatial frequencies are in
# the center of the 2D fourier transformed image.
fft_coeff_shifted = fftpack.fftshift(fft_coeff)
# calculate a 3D power spectrum
power_spect = np.abs(fft_coeff_shifted)**2
if self.use_mask:
xc = (self.nx_fft - 1.0) / 2.0
yc = (self.ny_fft - 1.0) / 2.0
zc = (self.nz_fft - 1.0) / 2.0
# spherical mask
a, b, c = xc, yc, zc
x, y, z = np.ogrid[-a:self.nx_fft - a, -b:self.ny_fft - b,
-c:self.nz_fft - c]
mask_int = x * x + y * y + z * z <= self.mask_r_min * self.mask_r_min
mask_out = x * x + y * y + z * z >= self.mask_r_max * self.mask_r_max
for i in range(self.nx_fft):
for j in range(self.ny_fft):
for k in range(self.nz_fft):
if mask_int[i, j, k]:
power_spect[i, j, k] = 0.0
if mask_out[i, j, k]:
power_spect[i, j, k] = 0.0
# cut the spectrum and keep only the relevant part for crystal-structure recognition of
# hexagonal closed packed (spacegroup=194)
# simple cubic (spacegroup=221)
# face centered cubic (spacegroup=225)
# diamond (spacegroup=227)
# body centered cubic (spacegroup=229)
# this interval (20:108) might need to be varied if other classes are added
power_spect_cut = power_spect[20:108, 20:108, 20:108]
# zoom by two times using spline interpolation
power_spect = ndimage.zoom(power_spect_cut, (2, 2, 2))
if save_diff_intensity:
np.save(
'/home/ziletti/Documents/calc_nomadml/rot_inv_3d/power_spect.npy',
power_spect)
# power_spect.shape = 176, 176, 176
if plot_3d:
plot_3d_volume(power_spect)
vox = np.copy(power_spect)
logger.debug("nan in data: {}".format(
np.count_nonzero(~np.isnan(vox))))
# optimized
# these specifications are valid for a power_spect = power_spect[20:108, 20:108, 20:108]
# and a magnification of 2
xyz_indices_r = get_slice_volume_indices(
vox,
min_r=32.0,
dr=1.0,
max_r=83.,
phi_bins=self.phi_bins,
theta_bins=self.theta_bins)
# slow - only for benchmarking the fast implementation below (shells_to_sph, interp_theta_phi_surfaces)
# (vox_by_slices, theta_phi_by_slices) = _slice_3d_volume_slow(vox)
# convert 3d shells
(vox_by_slices, theta_phi_by_slices) = get_shells_from_indices(
xyz_indices_r, vox)
if plot_slices:
plot_concentric_shells(
vox_by_slices,
base_folder=self.configs['io']['main_folder'],
idx_slices=None,
create_animation=False)
image_by_slices = interp_theta_phi_surfaces(
theta_phi_by_slices,
theta_bins=self.theta_bins_fine,
phi_bins=self.phi_bins_fine)
if plot_slices_sph_coords:
plot_concentric_shells_spherical_coords(
image_by_slices,
base_folder=self.configs['io']['main_folder'],
idx_slices=None)
coeffs_list = []
nl_list = []
ls_list = []
for idx_slice in range(image_by_slices.shape[0]):
logger.debug("img #{} max: {}".format(
idx_slice, image_by_slices[idx_slice].max()))
# set to zero the spherical harmonics coefficients above self.sph_l_cutoff
coeffs = SHExpandDH(image_by_slices[idx_slice], sampling=2)
coeffs_filtered = coeffs.copy()
coeffs_filtered[:, self.sph_l_cutoff:, :] = 0.
coeffs = coeffs_filtered.copy()
nl = coeffs.shape[0]
ls = np.arange(nl)
coeffs_list.append(coeffs)
nl_list.append(nl)
ls_list.append(ls)
coeffs = np.asarray(coeffs_list).reshape(image_by_slices.shape[0],
coeffs.shape[0],
coeffs.shape[1],
coeffs.shape[2])
sh_coeffs_list = []
for idx_slice in range(coeffs.shape[0]):
sh_coeffs = SHCoeffs.from_array(coeffs[idx_slice])
sh_coeffs_list.append(sh_coeffs)
sh_spectrum_list = []
for sh_coeff in sh_coeffs_list:
sh_spectrum = sh_coeff.spectrum(convention='l2norm')
sh_spectrum_list.append(sh_spectrum)
sh_spectra = np.asarray(sh_spectrum_list).reshape(
coeffs.shape[0], -1)
# cut the spherical harmonics expansion to sph_l_cutoff order
logger.debug(
'Spherical harmonics spectra maximum before normalization: {}'.
format(sh_spectra.max()))
sh_spectra = sh_spectra[:, :self.sph_l_cutoff]
sh_spectra = (sh_spectra - sh_spectra.min()) / (sh_spectra.max() -
sh_spectra.min())
# add results in ASE structure info
descriptor_data = dict(descriptor_name=self.name,
descriptor_info=str(self),
diffraction_3d_sh_spectrum=sh_spectra)
else:
# return array with zeros for structures with less than min_nb_atoms
sh_spectra = np.zeros((52, int(self.sph_l_cutoff)))
descriptor_data = dict(descriptor_name=self.name,
descriptor_info=str(self),
diffraction_3d_sh_spectrum=sh_spectra)
structure.info['descriptor'] = descriptor_data
return structure
def test_compare_spheroid_with_map(tolerance=0.15):
"""
Compare the output of two diffraction patterns, one simulated with the direct formula and the other one from a 3D refractive index map on a regular grid
"""
src = condor.Source(wavelength=0.1E-9,
pulse_energy=1E-3,
focus_diameter=1E-6)
det = condor.Detector(distance=0.5,
pixel_size=750E-6,
nx=100,
ny=100,
cx=45,
cy=59)
angle_d = 72.
angle = angle_d / 360. * 2 * numpy.pi
rotation_axis = numpy.array([0.43, 0.643, 0.])
rotation_axis = rotation_axis / condor.utils.linalg.length(rotation_axis)
quaternion = condor.utils.rotation.quat(angle, rotation_axis[0],
rotation_axis[1], rotation_axis[2])
rotation_values = numpy.array([quaternion])
rotation_formalism = "quaternion"
rotation_mode = "extrinsic"
short_diameter = 25E-9 * 12 / 100.
long_diameter = 2 * short_diameter
spheroid_diameter = condor.utils.spheroid_diffraction.to_spheroid_diameter(
short_diameter / 2., long_diameter / 2.)
spheroid_flattening = condor.utils.spheroid_diffraction.to_spheroid_flattening(
short_diameter / 2., long_diameter / 2.)
# Ideal spheroid
par = condor.ParticleSpheroid(diameter=spheroid_diameter,
material_type="water",
flattening=spheroid_flattening,
rotation_values=rotation_values,
rotation_formalism=rotation_formalism,
rotation_mode=rotation_mode)
s = "particle_spheroid"
E = condor.Experiment(src, {s: par}, det)
res = E.propagate()
F_ideal = res["entry_1"]["data_1"]["data_fourier"]
# Map (spheroid)
par = condor.ParticleMap(diameter=spheroid_diameter,
material_type="water",
flattening=spheroid_flattening,
geometry="spheroid",
rotation_values=rotation_values,
rotation_formalism=rotation_formalism,
rotation_mode=rotation_mode)
s = "particle_map_spheroid"
E = condor.Experiment(src, {s: par}, det)
res = E.propagate()
F_map = res["entry_1"]["data_1"]["data_fourier"]
# Compare
I_ideal = abs(F_ideal)**2
I_map = abs(F_map)**2
if SAVE_OUTPUT:
import matplotlib.pyplot as pypl
pypl.imsave("./Ispheroid_sph.png", abs(I_ideal))
pypl.imsave("./Ispheroid_map.png", abs(I_map))
diff = I_ideal - I_map
err = abs(diff).sum() / ((I_ideal.sum() + I_map.sum()) / 2.)
assert err < tolerance
condor_detc_y, pm['detc_y'])
assert (condor_detd * 1e3) == pm[
'detd'], "Missmatch between condor file (%f) and config.ini (%f)" % (
condor_detd * 1e3, pm['detd'])
assert condor_pixsize * 1e3 == pm[
'pixsize'], "Missmatch between condor file (%f) and config.ini (%f)" % (
condor_pixsize * 1e3, pm['pixsize'])
assert condor_wavelength * 1e10 == pm[
'wavelength'], "Missmatch between condor file (%f) and config.ini (%f)" % (
condor_wavelength * 1e10, pm['wavelength'])
# CONDOR CALCULATION OF QMAP AND SOLID ANGLE
# ---------------------------------------------
det = condor.Detector(condor_detd,
condor_pixsize,
cx=condor_detc_x,
cy=condor_detc_y,
nx=condor_dets_x,
ny=condor_dets_y)
condor_X, condor_Y = det.generate_xypix(cx=det.get_cx_mean_value(),
cy=det.get_cy_mean_value())
condor_R = np.sqrt(condor_X**2 + condor_Y**2)
condor_qmap = det.generate_qmap(condor_wavelength,
cx=det.get_cx_mean_value(),
cy=det.get_cy_mean_value(),
order='xyz')
condor_qx = condor_qmap[:, :, 0].flatten()
condor_qy = condor_qmap[:, :, 1].flatten()
condor_qz = condor_qmap[:, :, 2].flatten()
condor_polar = det.calculate_polarization_factors(
cx=det.get_cx_mean_value(),
cy=det.get_cy_mean_value(),
def main():
"""Parse command line arguments and convert file"""
logging.basicConfig(filename='recon.log',
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s')
parser = py_utils.MyArgparser(description='CONDOR to det')
parser.add_argument('filename', help='CONDOR file', type=str)
parser.add_argument(
'-C',
'--corners',
help='Set corner pixels to be irrelevant. Default = False',
action='store_true',
default=False)
args = parser.special_parse_args()
logging.info('Starting condortodet...')
logging.info(' '.join(sys.argv))
pm = read_config.get_detector_config(args.config_file, show=args.vb) # pylint: disable=invalid-name
output_folder = read_config.get_filename(args.config_file, 'emc',
'output_folder')
det = detector.Detector()
with h5py.File(args.filename, 'r') as fptr:
condor_dets_x = fptr['detector']['nx'][0]
condor_dets_y = fptr['detector']['ny'][0]
condor_detc_x = fptr['detector']['cx'][0]
condor_detc_y = fptr['detector']['cy'][0]
condor_detd = fptr['detector']['distance'][0] # in units of m
condor_pixsize = fptr['detector']['pixel_size'][0] # in units of m
condor_wavelength = fptr['source/wavelength'][0] # in units of m
condor_mask = fptr['entry_1/data_1/mask'][0]
_test_match(condor_dets_x, pm['dets_x'])
_test_match(condor_dets_y, pm['dets_y'])
_test_match(condor_detc_x, pm['detc_x'])
_test_match(condor_detc_y, pm['detc_y'])
_test_match(condor_detd * 1e3, pm['detd'])
_test_match(condor_pixsize * 1e3, pm['pixsize'])
_test_match(condor_wavelength * 1e10, pm['wavelength'])
# CONDOR CALCULATION OF QMAP AND SOLID ANGLE
# ---------------------------------------------
cdet = condor.Detector(condor_detd,
condor_pixsize,
cx=condor_detc_x,
cy=condor_detc_y,
nx=condor_dets_x,
ny=condor_dets_y)
condor_X, condor_Y = cdet.generate_xypix(
cx=cdet.get_cx_mean_value(), # pylint: disable=invalid-name
cy=cdet.get_cy_mean_value())
condor_R = np.sqrt(condor_X**2 + condor_Y**2) # pylint: disable=invalid-name
condor_qmap = cdet.generate_qmap(condor_wavelength,
cx=cdet.get_cx_mean_value(),
cy=cdet.get_cy_mean_value(),
order='xyz')
condor_qx = condor_qmap[:, :, 0].flatten()
condor_qy = condor_qmap[:, :, 1].flatten()
condor_qz = condor_qmap[:, :, 2].flatten()
condor_polar = cdet.calculate_polarization_factors(
cx=cdet.get_cx_mean_value(),
cy=cdet.get_cy_mean_value(),
polarization='unpolarized').flatten()
det.corr = condor_polar * cdet.get_all_pixel_solid_angles(
cx=cdet.get_cx_mean_value(), cy=cdet.get_cy_mean_value()).flatten()
# DRAGONFLY CALCULATION OF QMAP AND SOLID ANGLE
# ---------------------------------------------
q_pm = read_config.compute_q_params(pm['detd'],
pm['dets_x'],
pm['dets_y'],
pm['pixsize'],
pm['wavelength'],
pm['ewald_rad'],
show=args.vb)
qscaling = 1. / pm['wavelength'] / q_pm['q_sep']
# RESCALE CONDOR Qs to match dragonfly convention
# -----------------------------------------------
det.qx = condor_qx / (2 * np.pi) * condor_wavelength * qscaling
det.qy = condor_qy / (2 * np.pi) * condor_wavelength * qscaling
det.qz = condor_qz / (2 * np.pi) * condor_wavelength * qscaling
if pm['mask_fname'] is None:
det.raw_mask = np.zeros(condor_mask.shape)
det.raw_mask[~(condor_mask == 0)] = 2
if args.corners:
rmax = min(condor_X.max(), np.abs(condor_X.min()), condor_Y.max(),
np.abs(condor_Y.min()))
det.raw_mask[condor_R > rmax] = 1
det.raw_mask = det.raw_mask.flatten()
else:
det.raw_mask = np.fromfile(pm['mask_fname'], '=u1')
det.detd = pm['detd'] / pm['pixsize']
det.ewald_rad = pm['ewald_rad']
det_file = output_folder + '/' + 'condor.dat'
sys.stderr.write('Writing detector file to %s\n' % det_file)
det.write(det_file)
# Scale map to refractive index
dn = mat.get_dn(photon_wavelength=wavelength)
dn_map3d = bin_map3d * dn
# Save map
with h5py.File("emd_1144.h5", "w") as f:
f["/dn_map"] = dn_map3d
f["/dx"] = dx
f["/wavelength"] = wavelength
# Source
src = condor.Source(wavelength=wavelength,
pulse_energy=1E-3,
focus_diameter=0.1E-6)
# Detector
det = condor.Detector(distance=0.4, pixel_size=125E-6, nx=512, ny=512)
# Particle
par = condor.ParticleMap(diameter=1E-9,
geometry="custom",
map3d=dn_map3d,
dx=dx,
rotation_formalism="quaternion",
rotation_values=[0.01, 0.69, 0.69, -0.22])
E = condor.Experiment(src, {"particle_map_1144": par}, det)
res = E.propagate()
W = condor.utils.cxiwriter.CXIWriter("./condor.cxi")
W.write(res)
W.close()
import numpy as np
import scipy.interpolate
import condor
# Number of frames
N = 100
# Dimensions in diffraction space
nx, ny, nz = (100, 100, 100)
S = condor.Source(wavelength=1E-9, focus_diameter=1E-6, pulse_energy=1E-3)
P = condor.ParticleMap(geometry="icosahedron",
diameter=100E-9,
material_type="cell",
rotation_formalism="random")
D = condor.Detector(pixel_size=1000E-6, distance=0.5, nx=nx, ny=ny)
E = condor.Experiment(source=S, particles={"particle_map": P}, detector=D)
points = []
values = []
for i in range(N):
res = E.propagate()
img = res["entry_1"]["data_1"]["data_fourier"]
qmap = E.get_qmap_from_cache()
c = 2 * np.pi * D.pixel_size / (S.photon.get_wavelength() * D.distance)
points.append(qmap.reshape((qmap.shape[0] * qmap.shape[1], 3)) / c)
values.append(img.flatten())
points = np.array(points)
points = points.reshape((points.shape[0] * points.shape[1], 3))
values = np.array(values).flatten()
import logging
logger = logging.getLogger('condor')
logger.setLevel("INFO")
#logger.setLevel("DEBUG")
out_dir = this_dir + "/pngs"
if os.path.exists(out_dir):
shutil.rmtree(out_dir)
os.mkdir(out_dir)
# Source
src = condor.Source(wavelength=0.1E-9, pulse_energy=1E-3, focus_diameter=1E-6)
# Detector
det = condor.Detector(distance=0.5, pixel_size=750E-6, nx=100,
ny=100) #, cx=55, cy=55)
#angles_d = numpy.array([0., 22.5, 45.])
angles_d = numpy.array([72.5])
for angle_d in angles_d:
angle = angle_d / 360. * 2 * numpy.pi
rotation_axis = numpy.array([1., 1., 0.]) / numpy.sqrt(2.)
quaternion = condor.utils.rotation.quat(angle, rotation_axis[0],
rotation_axis[1], rotation_axis[2])
rotation_values = numpy.array([quaternion])
rotation_formalism = "quaternion"
rotation_mode = "extrinsic"
#rotation_values = None
#rotation_formalism = "random"
def test_compare_atoms_with_map(tolerance=0.1):
"""
Compare the output of two diffraction patterns, one simulated with descrete atoms (spsim) and the other one from a 3D refractive index map on a regular grid.
"""
src = condor.Source(wavelength=0.1E-9,
pulse_energy=1E-3,
focus_diameter=1E-6)
det = condor.Detector(distance=0.5,
pixel_size=750E-6,
nx=100,
ny=100,
cx=45,
cy=59)
angle_d = 72.
angle = angle_d / 360. * 2 * numpy.pi
rotation_axis = numpy.array([0.43, 0.643, 0.])
rotation_axis = rotation_axis / condor.utils.linalg.length(rotation_axis)
quaternion = condor.utils.rotation.quat(angle, rotation_axis[0],
rotation_axis[1], rotation_axis[2])
rotation_values = numpy.array([quaternion])
rotation_formalism = "quaternion"
rotation_mode = "extrinsic"
short_diameter = 25E-9 * 12 / 100.
long_diameter = 2 * short_diameter
N_long = 20
N_short = int(round(short_diameter / long_diameter * N_long))
dx = long_diameter / (N_long - 1)
massdensity = condor.utils.material.get_atomic_mass(
"H") * scipy.constants.value("atomic mass constant") / dx**3
# Map
map3d = numpy.zeros(shape=(N_long, N_long, N_long))
map3d[:N_short, :, :N_short] = 1.
map3d[N_short:N_short + N_short, :N_short, :N_short] = 1.
par = condor.ParticleMap(diameter=long_diameter,
material_type="custom",
massdensity=massdensity,
atomic_composition={"H": 1.},
geometry="custom",
map3d=map3d,
dx=dx,
rotation_values=rotation_values,
rotation_formalism=rotation_formalism,
rotation_mode=rotation_mode)
s = "particle_map_custom"
E = condor.Experiment(src, {s: par}, det)
res = E.propagate()
F_map = res["entry_1"]["data_1"]["data_fourier"]
# Atoms
Z1, Y1, X1 = numpy.meshgrid(numpy.linspace(0, short_diameter, N_short),
numpy.linspace(0, long_diameter, N_long),
numpy.linspace(0, short_diameter, N_short),
indexing="ij")
Z2, Y2, X2 = numpy.meshgrid(numpy.linspace(0, short_diameter, N_short) +
long_diameter / 2.,
numpy.linspace(0, short_diameter, N_short),
numpy.linspace(0, short_diameter, N_short),
indexing="ij")
Z = numpy.concatenate((Z1.ravel(), Z2.ravel()))
Y = numpy.concatenate((Y1.ravel(), Y2.ravel()))
X = numpy.concatenate((X1.ravel(), X2.ravel()))
atomic_positions = numpy.array(
[[x, y, z] for x, y, z in zip(X.ravel(), Y.ravel(), Z.ravel())])
atomic_numbers = numpy.ones(atomic_positions.size // 3, dtype=numpy.int16)
par = condor.ParticleAtoms(atomic_positions=atomic_positions,
atomic_numbers=atomic_numbers,
rotation_values=rotation_values,
rotation_formalism=rotation_formalism,
rotation_mode=rotation_mode)
s = "particle_atoms"
E = condor.Experiment(src, {s: par}, det)
res = E.propagate()
F_atoms = res["entry_1"]["data_1"]["data_fourier"]
# Compare
I_atoms = abs(F_atoms)**2
I_map = abs(F_map)**2
diff = I_atoms - I_map
err = abs(diff).sum() / ((I_atoms.sum() + I_map.sum()) / 2.)
if SAVE_OUTPUT:
import matplotlib.pyplot as pypl
pypl.imsave("./Iatoms_mol.png", abs(I_atoms))
pypl.imsave("./Iatoms_map.png", abs(I_map))
assert err < tolerance
import numpy
import condor
# Construct Source instance
src = condor.Source(wavelength=0.1E-9, pulse_energy=1E-3, focus_diameter=1E-6)
# Construct Detector instance
det = condor.Detector(distance=0.05, pixel_size=110E-6, nx=1000, ny=1000)
# Construct ParticleSphere instance
par = condor.ParticleSphere(diameter=1E-9, material_type="water")
# Combine source, detector, and particle by constructing Experiment instance
E = condor.Experiment(src, {"particle_sphere" : par}, det)
# Calculate diffraction pattern and obtain results in a dict
res = E.propagate()
# Arrays for Fourier and real space
data_fourier = res["entry_1"]["data_1"]["data_fourier"]
real_space = numpy.fft.fftshift(numpy.fft.ifftn(data_fourier))
fluence = 1e15 #[ph/um2]
focus_diameter = 0.2e-6
pulse_energy = fluence * ph.get_energy() * (np.pi * (
(1e6 * focus_diameter / 2.)**2)) # [J]
# Sample
pdb_id = '1FFK'
sample_size = 18e-9
# Simulation
src = condor.Source(wavelength=wavelength,
pulse_energy=pulse_energy,
focus_diameter=focus_diameter)
det = condor.Detector(distance=detector_distance,
pixel_size=pixelsize,
nx=nx,
ny=ny,
noise="poisson")
par = condor.ParticleAtoms(pdb_id=pdb_id, rotation_formalism="random")
E = condor.Experiment(source=src,
particles={"particle_atoms": par},
detector=det)
# Run multiple times and Save to file
N = 100
W = condor.utils.cxiwriter.CXIWriter(
"../data/single_protein_diffraction_patterns.h5")
for i in range(N):
o = E.propagate()
W.write(o)
W.close()
