def setUp(self):
L = 32
n = 64
pixel_size = 5
voltage = 200
defocus_min = 1.5e4
defocus_max = 2.5e4
defocus_ct = 7
Cs = 2.0
alpha = 0.1
self.dtype = np.float32
filters = [
RadialCTFFilter(pixel_size, voltage, defocus=d, Cs=Cs, alpha=alpha)
for d in np.linspace(defocus_min, defocus_max, defocus_ct)
]
vols = Volume(
np.load(os.path.join(DATA_DIR, "clean70SRibosome_vol.npy")).astype(
self.dtype))
vols = vols.downsample((L * np.ones(3, dtype=int)))
sim = Simulation(L=L,
n=n,
vols=vols,
unique_filters=filters,
dtype=self.dtype)
self.orient_est = CLSyncVoting(sim, L // 2, 36)
def testDownsample(self):
# Data files re-used from test_preprocess
vols = Volume(
np.load(os.path.join(DATA_DIR, "clean70SRibosome_vol.npy")))
resv = Volume(
np.load(os.path.join(DATA_DIR, "clean70SRibosome_vol_down8.npy")))
result = vols.downsample((8, 8, 8))
self.assertTrue(np.allclose(result, resv))
self.assertTrue(isinstance(result, Volume))
def setUp(self):
self.dtype = np.float32
L = 8
n = 32
pixel_size = 5.0 * 65 / L
voltage = 200
defocus_min = 1.5e4
defocus_max = 2.5e4
defocus_ct = 7
self.noise_var = 1.3957e-4
noise_filter = ScalarFilter(dim=2, value=self.noise_var)
unique_filters = [
RadialCTFFilter(pixel_size, voltage, defocus=d, Cs=2.0, alpha=0.1)
for d in np.linspace(defocus_min, defocus_max, defocus_ct)
]
vols = Volume(
np.load(os.path.join(DATA_DIR, "clean70SRibosome_vol.npy")).astype(
self.dtype
)
) # RCOPT
vols = vols.downsample((L * np.ones(3, dtype=int))) * 1.0e3
# Since FFBBasis2D doesn't yet implement dtype, we'll set this to double to match its built in types.
sim = Simulation(
n=n,
L=L,
vols=vols,
unique_filters=unique_filters,
offsets=0.0,
amplitudes=1.0,
dtype=self.dtype,
noise_filter=noise_filter,
)
self.basis = FFBBasis2D((L, L), dtype=self.dtype)
self.h_idx = sim.filter_indices
self.h_ctf_fb = [filt.fb_mat(self.basis) for filt in unique_filters]
self.imgs_clean = sim.projections()
self.imgs_ctf_clean = sim.clean_images()
self.imgs_ctf_noise = sim.images(start=0, num=n)
self.cov2d = RotCov2D(self.basis)
self.coeff_clean = self.basis.evaluate_t(self.imgs_clean)
self.coeff = self.basis.evaluate_t(self.imgs_ctf_noise)
def setUp(self):
self.resolution = 16
self.dtype = np.float64
# Create some projections
v = Volume(
np.load(os.path.join(DATA_DIR, "clean70SRibosome_vol.npy")).astype(
self.dtype))
v = v.downsample(self.resolution)
# Clean
self.clean_src = Simulation(
L=self.resolution,
n=321,
vols=v,
dtype=self.dtype,
)
# With Noise
noise_var = 0.01 * np.var(np.sum(v[0], axis=0))
noise_filter = ScalarFilter(dim=2, value=noise_var)
self.noisy_src = Simulation(
L=self.resolution,
n=123,
vols=v,
dtype=self.dtype,
noise_filter=noise_filter,
)
# Set up FFB
# Setup a Basis
self.basis = FFBBasis2D((self.resolution, self.resolution),
dtype=self.dtype)
# Create Basis, use precomputed Basis
self.clean_fspca_basis = FSPCABasis(
self.clean_src, self.basis, noise_var=0
) # Note noise_var assigned zero, skips eigval filtering.
# Ceate another fspca_basis, use autogeneration FFB2D Basis
self.noisy_fspca_basis = FSPCABasis(self.noisy_src)
def setUp(self):
self.resolution = 16
self.dtype = np.float32
# Get a volume
v = Volume(
np.load(os.path.join(DATA_DIR, "clean70SRibosome_vol.npy")).astype(
self.dtype))
v = v.downsample(self.resolution)
# Create a src from the volume
self.src = Simulation(
L=self.resolution,
n=321,
vols=v,
dtype=self.dtype,
)
# Calculate some projection images
self.imgs = self.src.images(0, self.src.n)
# Configure an FSPCA basis
self.fspca_basis = FSPCABasis(self.src, noise_var=0)
filters = [
RadialCTFFilter(pixel_size, voltage, defocus=d, Cs=2.0, alpha=0.1)
for d in np.linspace(defocus_min, defocus_max, defocus_ct)
]
# %%
# Downsampling
# ------------
# Load the map file of a 70S Ribosome and downsample the 3D map to desired resolution.
# The downsampling should be done by the internal function of Volume object in future.
logger.info(f"Load 3D map and downsample 3D map to desired grids "
f"of {img_size} x {img_size} x {img_size}.")
infile = mrcfile.open(os.path.join(DATA_DIR, "clean70SRibosome_vol_65p.mrc"))
vols = Volume(infile.data.astype(dtype))
vols = vols.downsample((img_size, ) * 3)
# %%
# Create Simulation Object and Obtain True Rotation Angles
# --------------------------------------------------------
# Create a simulation object with specified filters and the downsampled 3D map
logger.info("Use downsampled map to creat simulation object.")
sim = Simulation(L=img_size,
n=num_imgs,
vols=vols,
unique_filters=filters,
dtype=dtype)
logger.info(
"Get true rotation angles generated randomly by the simulation object.")
logger.info("Initialize simulation object and CTF filters.")
# Create filters
ctf_filters = [
RadialCTFFilter(pixel_size, voltage, defocus=d, Cs=2.0, alpha=0.1)
for d in np.linspace(defocus_min, defocus_max, defocus_ct)
]
# Load the map file of a 70S Ribosome
logger.info(
f"Load 3D map and downsample 3D map to desired grids "
f"of {img_size} x {img_size} x {img_size}."
)
infile = mrcfile.open(os.path.join(DATA_DIR, "clean70SRibosome_vol_65p.mrc"))
# We prefer that our various arrays have consistent dtype.
vols = Volume(infile.data.astype(dtype) / np.max(infile.data))
vols = vols.downsample(img_size)
# Create a simulation object with specified filters and the downsampled 3D map
logger.info("Use downsampled map to creat simulation object.")
sim = Simulation(
L=img_size,
n=num_imgs,
vols=vols,
unique_filters=ctf_filters,
offsets=0.0,
amplitudes=1.0,
dtype=dtype,
noise_filter=noise_filter,
)
# Specify the fast FB basis method for expending the 2D images
# A low res example file is included in the repo as a sanity check.
DATA_DIR = "data"
infile = mrcfile.open(os.path.join(DATA_DIR, "clean70SRibosome_vol_65p.mrc"))
# More interesting data requires downloading locally.
# infile = mrcfile.open("EMD-2660/map/emd_2660.map")
d = infile.data
logger.info(f"map data shape: {d.shape} dtype:{d.dtype}")
v = Volume(d)
# Downsample the volume to a desired resolution
img_size = 64
# Volume.downsample() Returns a new Volume instance.
# We will use this lower resolution volume later.
v2 = v.downsample((img_size, img_size, img_size))
L = v2.resolution
# %%
# Contour Plot of Data
# --------------------
# Alternatively, for quick sanity checking purposes we can view as a contour plot.
# We'll use three orthographic projections, one per axis.
for axis in range(3):
plt.contourf(np.arange(L), np.arange(L), np.sum(v2[0], axis=axis))
plt.show()
# %%
# Scatter Plot
# ------------
