def get_model_map_coeffs_normalized(pdb_inp=None,
si=None,
f_array=None,
overall_b=None,
resolution=None,
n_bins=None,
target_b_iso_model_scale=0,
out=sys.stdout):
if not pdb_inp: return None
if not si:
from cctbx.maptbx.segment_and_split_map import sharpening_info
si=sharpening_info(resolution=resolution,
target_b_iso_model_scale=0,
n_bins=n_bins)
# define Wilson B for the model
if overall_b is None:
if si.resolution:
overall_b=si.get_target_b_iso()*si.target_b_iso_model_scale
else:
overall_b=0
print("Setting Wilson B = %5.1f A" %(overall_b), file=out)
# create model map using same coeffs
from cctbx.maptbx.segment_and_split_map import get_f_phases_from_model
try:
model_map_coeffs=get_f_phases_from_model(
pdb_inp=pdb_inp,
f_array=f_array,
overall_b=overall_b,
k_sol=si.k_sol,
b_sol=si.b_sol,
out=out)
except Exception as e:
print ("Failed to get model map coeffs...going on",file=out)
return None
from cctbx.maptbx.segment_and_split_map import map_coeffs_as_fp_phi,get_b_iso
model_f_array,model_phases=map_coeffs_as_fp_phi(model_map_coeffs)
(d_max,d_min)=f_array.d_max_min()
model_f_array.setup_binner(n_bins=si.n_bins,d_max=d_max,d_min=d_min)
# Set overall_b....
final_b_iso=get_b_iso(model_f_array,d_min=resolution)
print("Effective b_iso of "+\
"adjusted model map: %6.1f A**2" %(final_b_iso), file=out)
model_map_coeffs_normalized=model_f_array.phase_transfer(
phase_source=model_phases,deg=True)
return model_map_coeffs_normalized
def run(map_coeffs=None,
b=[0,0,0],
sharpening_info_obj=None,
resolution=None,
residual_target=None,
solvent_fraction=None,
region_weight=None,
max_regions_to_test=None,
sa_percent=None,
fraction_occupied=None,
n_bins=None,
eps=None,
wrapping=False,
n_real=False,
target_sthol2=None,
target_scale_factors=None,
d_min_ratio=None,
rmsd=None,
fraction_complete=None,
normalize_amplitudes_in_resdep=None,
out=sys.stdout):
if sharpening_info_obj:
solvent_fraction=sharpening_info_obj.solvent_fraction
wrapping=sharpening_info_obj.wrapping
n_real=sharpening_info_obj.n_real
fraction_occupied=sharpening_info_obj.fraction_occupied
sa_percent=sharpening_info_obj.sa_percent
region_weight=sharpening_info_obj.region_weight
max_regions_to_test=sharpening_info_obj.max_regions_to_test
residual_target=sharpening_info_obj.residual_target
resolution=sharpening_info_obj.resolution
d_min_ratio=sharpening_info_obj.d_min_ratio
rmsd=sharpening_info_obj.rmsd
fraction_complete=sharpening_info_obj.fraction_complete
eps=sharpening_info_obj.eps
n_bins=sharpening_info_obj.n_bins
normalize_amplitudes_in_resdep= \
sharpening_info_obj.normalize_amplitudes_in_resdep
else:
from cctbx.maptbx.segment_and_split_map import sharpening_info
sharpening_info_obj=sharpening_info()
if map_coeffs:
phases=map_coeffs.phases(deg=True)
ma=map_coeffs.as_amplitude_array()
else:
phases=None
ma=None
# set some defaults
if residual_target is None: residual_target='kurtosis'
assert (solvent_fraction is not None ) or residual_target=='kurtosis'
assert resolution is not None
if residual_target=='adjusted_sa' and solvent_fraction is None:
raise Sorry("Solvent fraction is required for residual_target=adjusted_sa")
if eps is None and residual_target=='kurtosis':
eps=0.01
elif eps is None:
eps=0.5
if fraction_complete is None:
pass # XXX not implemented
if rmsd is None:
rmsd=resolution/3.
print("Setting rmsd to %5.1f A based on resolution of %5.1f A" %(
rmsd,resolution), file=out)
if fraction_occupied is None: fraction_occupied=0.20
if region_weight is None: region_weight=20.
if sa_percent is None: sa_percent=30.
if n_bins is None: n_bins=20
if max_regions_to_test is None: max_regions_to_test=30
# Get initial value
best_b=b
print("Getting starting value ...",residual_target, file=out)
refined = refinery(ma,phases,b,resolution,
residual_target=residual_target,
solvent_fraction=solvent_fraction,
region_weight=region_weight,
sa_percent=sa_percent,
max_regions_to_test=max_regions_to_test,
fraction_occupied=fraction_occupied,
wrapping=wrapping,
n_real=n_real,
target_sthol2=target_sthol2,
target_scale_factors=target_scale_factors,
d_min_ratio=d_min_ratio,
rmsd=rmsd,
fraction_complete=fraction_complete,
eps=eps)
starting_result=refined.show_result(out=out)
print("Starting value: %7.2f" %(starting_result), file=out)
if ma:
(d_max,d_min)=ma.d_max_min()
ma.setup_binner(n_bins=n_bins,d_max=d_max,d_min=d_min)
if normalize_amplitudes_in_resdep:
print("Normalizing structure factors...", file=out)
ma=quasi_normalize_structure_factors(ma,set_to_minimum=0.01)
else:
assert resolution is not None
refined = refinery(ma,phases,b,resolution,
residual_target=residual_target,
solvent_fraction=solvent_fraction,
region_weight=region_weight,
max_regions_to_test=max_regions_to_test,
sa_percent=sa_percent,
fraction_occupied=fraction_occupied,
wrapping=wrapping,
n_real=n_real,
target_sthol2=target_sthol2,
target_scale_factors=target_scale_factors,
d_min_ratio=d_min_ratio,
rmsd=rmsd,
fraction_complete=fraction_complete,
eps=eps)
starting_normalized_result=refined.show_result(out=out)
print("Starting value after normalization: %7.2f" %(
starting_normalized_result), file=out)
best_sharpened_ma=ma
best_result=starting_normalized_result
best_b=refined.get_b()
refined.run()
final_result=refined.show_result(out=out)
print("Final value: %7.2f" %(
final_result), file=out)
if final_result>best_result:
best_sharpened_ma=refined.sharpened_ma
best_result=final_result
best_b=refined.get_b()
print("Best overall result: %7.2f: " %(best_result), file=out)
sharpening_info_obj.resolution_dependent_b=best_b
return best_sharpened_ma,phases
