def show_cycle_summary(self, out=None):
if not self.params.verbose: return
if out is None: out = sys.stdout
self.more_statistics = maptbx.more_statistics(self.map)
self._stats.add_cycle(
cycle=self.i_cycle+1,
radius=self.radius,
d_min=self.d_min,
mask_percent=self.mask_percent,
mean_solvent_density=self.mean_solvent_density,
mean_protein_density=self.mean_protein_density,
f000_over_v=self.f000_over_v,
truncate_density=self.truncate_density,
truncate_min=self.truncate_min,
truncate_min_percent=self.truncate_min_percent,
truncate_max=self.truncate_max,
truncate_max_percent=self.truncate_max_percent,
ncs_cc=self.ncs_cc,
k_flip=self.k_flip,
solvent_add=self.solvent_add,
rms_solvent_density=self.rms_solvent_density,
rms_protein_density=self.rms_protein_density,
standard_deviation_local_rms=self.standard_deviation_local_rms,
mean_delta_phi=flex.mean(self.mean_delta_phi)/pi_180,
mean_delta_phi_initial=flex.mean(self.mean_delta_phi_initial)/pi_180,
r1_factor=self.r1_factor,
r1_factor_fom=self.r1_factor_fom,
fom=self.mean_fom,
fom_binned=self.mean_fom_binned,
skewness=self.more_statistics.skewness())
summary = self._stats.format_summary()
print >> self.log, summary
self.log.flush()
if (not self.as_gui_program) :
libtbx.call_back(message="summary",
data=summary,
accumulate=True)
else :
libtbx.call_back(message="plot_current_stats",
data=self._stats.get_fom_for_plot())
def show_cycle_summary(self, out=None):
if not self.params.verbose: return
if out is None: out = sys.stdout
self.more_statistics = maptbx.more_statistics(self.map)
self._stats.add_cycle(
cycle=self.i_cycle+1,
radius=self.radius,
d_min=self.d_min,
mask_percent=self.mask_percent,
mean_solvent_density=self.mean_solvent_density,
mean_protein_density=self.mean_protein_density,
f000_over_v=self.f000_over_v,
truncate_density=self.truncate_density,
truncate_min=self.truncate_min,
truncate_min_percent=self.truncate_min_percent,
truncate_max=self.truncate_max,
truncate_max_percent=self.truncate_max_percent,
ncs_cc=self.ncs_cc,
k_flip=self.k_flip,
solvent_add=self.solvent_add,
rms_solvent_density=self.rms_solvent_density,
rms_protein_density=self.rms_protein_density,
standard_deviation_local_rms=self.standard_deviation_local_rms,
mean_delta_phi=flex.mean(self.mean_delta_phi)/pi_180,
mean_delta_phi_initial=flex.mean(self.mean_delta_phi_initial)/pi_180,
r1_factor=self.r1_factor,
r1_factor_fom=self.r1_factor_fom,
fom=self.mean_fom,
fom_binned=self.mean_fom_binned,
skewness=self.more_statistics.skewness())
summary = self._stats.format_summary()
print >> self.log, summary
self.log.flush()
if (not self.as_gui_program) :
libtbx.call_back(message="summary",
data=summary,
accumulate=True)
else :
libtbx.call_back(message="plot_current_stats",
data=self._stats.get_fom_for_plot())
def __init__(self,
params,
f_obs,
hl_coeffs_start,
ncs_object=None,
map_coeffs=None,
log=None,
as_gui_program=False):
if log is None: log = sys.stdout
adopt_init_args(self, locals())
if self.params.solvent_mask.averaging_radius.final is None:
if self.params.initial_d_min is not None:
self.params.solvent_mask.averaging_radius.final = self.params.initial_d_min
elif self.params.d_min is not None:
self.params.solvent_mask.averaging_radius.final = self.params.d_min
else:
self.params.solvent_mask.averaging_radius.final = self.f_obs.d_min(
)
if self.params.solvent_mask.averaging_radius.initial is None:
self.params.solvent_mask.averaging_radius.initial = \
self.params.solvent_mask.averaging_radius.final + 1
self.matthews_analysis()
self.anisotropic_correction()
self.change_of_basis_op = None
if self.params.change_basis_to_niggli_cell:
self.change_of_basis_op = self.f_obs.change_of_basis_op_to_niggli_cell(
)
if self.change_of_basis_op.is_identity_op():
self.change_of_basis_op = None
if self.change_of_basis_op is not None:
self.f_obs = self.f_obs.change_basis(
self.change_of_basis_op).map_to_asu()
self.hl_coeffs_start = self.hl_coeffs_start.change_basis(
self.change_of_basis_op).map_to_asu()
if self.map_coeffs is not None:
self.map_coeffs = self.map_coeffs.change_basis(
self.change_of_basis_op).map_to_asu()
self.mean_solvent_density = 0
self.phase_source_initial = None
self.phase_source = None
if self.params.d_min is None:
if self.params.phase_extension:
self.params.d_min = self.f_obs.d_min()
else:
self.params.d_min = self.hl_coeffs_start.d_min()
if self.params.initial_d_min is None:
self.params.initial_d_min = self.params.d_min
assert self.params.initial_d_min >= self.params.d_min
self.max_iterations = sum(
(self.params.initial_steps, self.params.shrink_steps,
self.params.final_steps))
self.i_cycle = 0
if self.params.shrink_steps is not None and self.params.shrink_steps > 0:
self.radius_delta = (self.params.solvent_mask.averaging_radius.initial
- self.params.solvent_mask.averaging_radius.final) \
/ self.params.shrink_steps
if self.params.phase_extension:
self.phase_extend_step = (
self.params.initial_d_min -
self.params.d_min) / self.params.shrink_steps
else:
self.phase_extend_step = 0
self.params.initial_d_min = self.params.d_min
self.complete_set = self.f_obs.complete_set()
if (self.f_obs.sigmas() is not None):
ref_active = (self.f_obs.sigmas() > 0) \
& (self.f_obs.d_spacings().data() >= self.params.d_min)
else:
ref_active = (self.f_obs.d_spacings().data() >= self.params.d_min)
sigma_cutoff = 0
obs_rms = 1e4
obs_high = rms(self.f_obs.select(ref_active).data()) * obs_rms
obs_low = flex.min(self.f_obs.select(ref_active).data())
if (self.f_obs.sigmas() is not None):
self.ref_flags_array = self.f_obs.array(
data=((self.f_obs.data() > sigma_cutoff * self.f_obs.sigmas())
& (self.f_obs.data() >= obs_low)
& (self.f_obs.data() <= obs_high)
& (self.f_obs.d_spacings().data() > self.params.d_min)))
else:
self.ref_flags_array = self.f_obs.array(
data=((self.f_obs.data() >= obs_low)
& (self.f_obs.data() <= obs_high)
& (self.f_obs.d_spacings().data() > self.params.d_min)))
# now setup for complete arrays
self.ref_flags_array = self.ref_flags_array.complete_array(
new_data_value=False, d_min=self.params.d_min)
self.ref_flags = self.ref_flags_array.data()
self.f_obs_complete = self.f_obs.complete_array(
new_data_value=0, new_sigmas_value=0, d_min=self.params.d_min)
self.hl_coeffs_start = self.hl_coeffs_start.complete_array(
new_data_value=(0, 0, 0, 0), d_min=self.params.d_min)
self.hl_coeffs = self.hl_coeffs_start.select_indices(
self.active_indices)
hl_coeffs = self.hl_coeffs
self.compute_phase_source(hl_coeffs)
fom = flex.abs(self.phase_source.data())
fom.set_selected(hl_coeffs.data() == (0, 0, 0, 0), 0)
self.fom = fom
if self.map_coeffs is None:
self.map_coeffs = self.f_obs_active.customized_copy(
data=self.f_obs_active.data() * fom,
sigmas=None).phase_transfer(phase_source=self.hl_coeffs)
self.map_coeffs.data().set_selected(fom <= 0, 0)
self.map = self.map_coeffs.select(fom > 0).fft_map(
symmetry_flags=maptbx.use_space_group_symmetry,
resolution_factor=self.params.grid_resolution_factor
).apply_volume_scaling().real_map_unpadded()
self.map_coeffs = self.map_coeffs.select(fom > 0)
else:
assert self.map_coeffs.is_complex_array()
self.map = self.map_coeffs.fft_map(
symmetry_flags=maptbx.use_space_group_symmetry,
resolution_factor=self.params.grid_resolution_factor
).apply_volume_scaling().real_map_unpadded()
self.map_coeffs_start = self.map_coeffs
self.calculate_solvent_mask()
n_phased = (fom > 0).count(True)
if params.verbose:
summary = "n phased: %d\n" % n_phased
summary += "Mean solvent density: %.4f\n" % self.mean_solvent_density
summary += "Mean protein density: %.4f\n" % self.mean_protein_density
summary += "RMS solvent density: %.4f\n" % self.rms_solvent_density
summary += "RMS protein density: %.4f\n" % self.rms_protein_density
summary += "RMS solvent/protein density ratio: %.4f\n" % (
self.rms_solvent_density / self.rms_protein_density)
summary += "F000/V: %.4f\n" % self.f000_over_v
summary += "Mean FOM: %.4f\n" % flex.mean(fom.select(fom > 0))
print >> self.log, summary
libtbx.call_back(message="summary", data=summary)
# XXX initialize printable statistics
self.truncate_min = None
self.truncate_min_percent = None
self.truncate_max = None
self.truncate_max_percent = None
self.k_flip = None
self.solvent_add = None
self.truncate_density = \
(self.params.density_truncation.fraction_max is not None or
self.params.density_truncation.fraction_min is not None)
self._stats = dm_stats()
self._stats.add_cycle(cycle=0,
mean_solvent_density=self.mean_solvent_density,
mean_protein_density=self.mean_protein_density,
f000_over_v=self.f000_over_v,
rms_solvent_density=self.rms_solvent_density,
rms_protein_density=self.rms_protein_density,
fom=flex.mean(fom.select(fom > 0)))
libtbx.call_back("start_progress_bar",
data=group_args(label="Running %d cycles..." %
self.max_iterations,
size=self.max_iterations))
for self.i_cycle in range(self.max_iterations):
self.next_cycle()
libtbx.call_back(message="increment_progress_bar",
data=group_args(chunk=1),
cached=False)
libtbx.call_back("end_progress_bar", data=None)
def __init__(self,
params,
f_obs,
hl_coeffs_start,
ncs_object=None,
map_coeffs=None,
log=None,
as_gui_program=False):
if log is None: log = sys.stdout
adopt_init_args(self, locals())
if self.params.solvent_mask.averaging_radius.final is None:
if self.params.initial_d_min is not None:
self.params.solvent_mask.averaging_radius.final = self.params.initial_d_min
elif self.params.d_min is not None:
self.params.solvent_mask.averaging_radius.final = self.params.d_min
else:
self.params.solvent_mask.averaging_radius.final = self.f_obs.d_min()
if self.params.solvent_mask.averaging_radius.initial is None:
self.params.solvent_mask.averaging_radius.initial = \
self.params.solvent_mask.averaging_radius.final + 1
self.matthews_analysis()
self.anisotropic_correction()
self.change_of_basis_op = None
if self.params.change_basis_to_niggli_cell:
self.change_of_basis_op = self.f_obs.change_of_basis_op_to_niggli_cell()
if self.change_of_basis_op.is_identity_op():
self.change_of_basis_op = None
if self.change_of_basis_op is not None:
self.f_obs = self.f_obs.change_basis(self.change_of_basis_op).map_to_asu()
self.hl_coeffs_start = self.hl_coeffs_start.change_basis(
self.change_of_basis_op).map_to_asu()
if self.map_coeffs is not None:
self.map_coeffs = self.map_coeffs.change_basis(
self.change_of_basis_op).map_to_asu()
self.mean_solvent_density = 0
self.phase_source_initial = None
self.phase_source = None
if self.params.d_min is None:
if self.params.phase_extension:
self.params.d_min = self.f_obs.d_min()
else:
self.params.d_min = self.hl_coeffs_start.d_min()
if self.params.initial_d_min is None:
self.params.initial_d_min = self.params.d_min
assert self.params.initial_d_min >= self.params.d_min
self.max_iterations = sum((self.params.initial_steps,
self.params.shrink_steps,
self.params.final_steps))
self.i_cycle = 0
if self.params.shrink_steps is not None and self.params.shrink_steps > 0:
self.radius_delta = (self.params.solvent_mask.averaging_radius.initial
- self.params.solvent_mask.averaging_radius.final) \
/ self.params.shrink_steps
if self.params.phase_extension:
self.phase_extend_step = (
self.params.initial_d_min - self.params.d_min)/self.params.shrink_steps
else:
self.phase_extend_step = 0
self.params.initial_d_min = self.params.d_min
self.complete_set = self.f_obs.complete_set()
if(self.f_obs.sigmas() is not None):
ref_active = (self.f_obs.sigmas() > 0) \
& (self.f_obs.d_spacings().data() >= self.params.d_min)
else:
ref_active = (self.f_obs.d_spacings().data() >= self.params.d_min)
sigma_cutoff = 0
obs_rms = 1e4
obs_high = rms(self.f_obs.select(ref_active).data()) * obs_rms
obs_low = flex.min(self.f_obs.select(ref_active).data())
if(self.f_obs.sigmas() is not None):
self.ref_flags_array = self.f_obs.array(data=(
(self.f_obs.data() > sigma_cutoff*self.f_obs.sigmas())
& (self.f_obs.data() >= obs_low)
& (self.f_obs.data() <= obs_high)
& (self.f_obs.d_spacings().data() > self.params.d_min)))
else:
self.ref_flags_array = self.f_obs.array(data=(
(self.f_obs.data() >= obs_low)
& (self.f_obs.data() <= obs_high)
& (self.f_obs.d_spacings().data() > self.params.d_min)))
# now setup for complete arrays
self.ref_flags_array = self.ref_flags_array.complete_array(
new_data_value=False, d_min=self.params.d_min)
self.ref_flags = self.ref_flags_array.data()
self.f_obs_complete = self.f_obs.complete_array(
new_data_value=0, new_sigmas_value=0, d_min=self.params.d_min)
self.hl_coeffs_start = self.hl_coeffs_start.complete_array(
new_data_value=(0,0,0,0), d_min=self.params.d_min)
self.hl_coeffs = self.hl_coeffs_start.select_indices(self.active_indices)
hl_coeffs = self.hl_coeffs
self.compute_phase_source(hl_coeffs)
fom = flex.abs(self.phase_source.data())
fom.set_selected(hl_coeffs.data() == (0,0,0,0), 0)
self.fom = fom
if self.map_coeffs is None:
self.map_coeffs = self.f_obs_active.customized_copy(
data=self.f_obs_active.data()*fom,
sigmas=None).phase_transfer(phase_source=self.hl_coeffs)
self.map_coeffs.data().set_selected(fom <= 0, 0)
self.map = self.map_coeffs.select(fom > 0).fft_map(
symmetry_flags=maptbx.use_space_group_symmetry,
resolution_factor=self.params.grid_resolution_factor
).apply_volume_scaling().real_map_unpadded()
self.map_coeffs = self.map_coeffs.select(fom > 0)
else:
assert self.map_coeffs.is_complex_array()
self.map = self.map_coeffs.fft_map(
symmetry_flags=maptbx.use_space_group_symmetry,
resolution_factor=self.params.grid_resolution_factor
).apply_volume_scaling().real_map_unpadded()
self.map_coeffs_start = self.map_coeffs
self.calculate_solvent_mask()
n_phased = (fom > 0).count(True)
if params.verbose:
summary = "n phased: %d\n" % n_phased
summary += "Mean solvent density: %.4f\n" %self.mean_solvent_density
summary += "Mean protein density: %.4f\n" %self.mean_protein_density
summary += "RMS solvent density: %.4f\n" %self.rms_solvent_density
summary += "RMS protein density: %.4f\n" %self.rms_protein_density
summary += "RMS solvent/protein density ratio: %.4f\n" %(
self.rms_solvent_density/self.rms_protein_density)
summary += "F000/V: %.4f\n" %self.f000_over_v
summary += "Mean FOM: %.4f\n" %flex.mean(fom.select(fom>0))
print >> self.log, summary
libtbx.call_back(message="summary", data=summary)
# XXX initialize printable statistics
self.truncate_min = None
self.truncate_min_percent = None
self.truncate_max = None
self.truncate_max_percent = None
self.k_flip = None
self.solvent_add = None
self.truncate_density = \
(self.params.density_truncation.fraction_max is not None or
self.params.density_truncation.fraction_min is not None)
self._stats = dm_stats()
self._stats.add_cycle(
cycle=0,
mean_solvent_density=self.mean_solvent_density,
mean_protein_density=self.mean_protein_density,
f000_over_v=self.f000_over_v,
rms_solvent_density=self.rms_solvent_density,
rms_protein_density=self.rms_protein_density,
fom=flex.mean(fom.select(fom>0)))
libtbx.call_back("start_progress_bar",
data=group_args(label="Running %d cycles..." % self.max_iterations,
size=self.max_iterations))
for self.i_cycle in range(self.max_iterations):
self.next_cycle()
libtbx.call_back(message="increment_progress_bar",
data=group_args(chunk=1),
cached=False)
libtbx.call_back("end_progress_bar", data=None)
