def run(args):
assert len(args) == 1
# Read file into pdb_input class
inp = iotbx.pdb.input(file_name=args[0])
# create a model manager
model = mmtbx.model.manager(model_input=inp)
# get number of atoms in the input model
n_atoms = model.get_number_of_atoms()
# extract atom coordinates
old_sites_cart = model.get_sites_cart()
# generate random additions
random_addition = flex.vec3_double(
flex.random_double(size=n_atoms * 3) - 0.5)
# actually add them to old coordinates
new_xyz = old_sites_cart + random_addition
# Update coordinates in model manager
model.set_sites_cart(sites_cart=new_xyz)
# get xray structure
xrs = model.get_xray_structure()
# reset B-factors (min=1, max=20)
# generate array of new B-factors
new_b = flex.random_double(size=n_atoms, factor=19) + 1
# set them in xray structure
xrs.set_b_iso(values=new_b)
# update model manager with this xray structure
model.set_xray_structure(xrs)
# output result in PDB format to the screen
print model.model_as_pdb()
print "END"
def run(args):
log = sys.stdout
if (len(args) == 0): args = ["--help"]
command_line = (option_parser(usage="%s [options] pdb_file" %
libtbx.env.dispatcher_name).option(
None,
"--buffer_layer",
action="store",
type="float",
default=5)).process(args=args, nargs=1)
pdb_inp = iotbx.pdb.input(file_name=command_line.args[0])
model = mmtbx.model.manager(model_input=pdb_inp)
box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center(
sites_cart=model.get_sites_cart(),
buffer_layer=command_line.options.buffer_layer)
model.set_sites_cart(box.sites_cart)
# Bad hack, never repeat. In fact, all the boxing functionality should
# go into mmtbx.model.manager
model._crystal_symmetry = box.crystal_symmetry()
print('REMARK %s --buffer-layer=%.6g %s' %
(libtbx.env.dispatcher_name, command_line.options.buffer_layer,
show_string(command_line.args[0])),
file=log)
print('REMARK %s' % date_and_time(), file=log)
print(model.model_as_pdb(), file=log)
def run(pdb_file_name):
pdb_inp = iotbx.pdb.input(file_name=pdb_file_name)
params = mmtbx.model.manager.get_default_pdb_interpretation_params()
model = mmtbx.model.manager(
model_input = pdb_inp,
pdb_interpretation_params = params,
build_grm = True,
stop_for_unknowns = False,
log = null_out())
pdb_hierarchy = model.get_hierarchy()
sites_cart_dc = model.get_sites_cart().deep_copy()
angle = 0.
# points_i_seqs = [483]
# axis = [479,482]
points_i_seqs = [559]
axis = [556,557]
while angle <= 360:
atoms_xyz_tmp = flex.vec3_double(len(points_i_seqs))
atom_xyz_new = rotate_point_around_axis(
axis_point_1 = sites_cart_dc[axis[0]],
axis_point_2 = sites_cart_dc[axis[1]],
point = sites_cart_dc[points_i_seqs[0]],
angle = angle,
deg = True)
print (atom_xyz_new)
atoms_xyz_tmp[0] = atom_xyz_new
sites_cart_dc[points_i_seqs] = atoms_xyz_tmp[0]
model.set_sites_cart(sites_cart = sites_cart_dc)
with open(str(angle)+".pdb", "w") as of:
print (model.model_as_pdb(),file=of)
angle += 30.
def run(args, params=None, out=sys.stdout, model=None):
if model is None:
if ( ((len(args) == 0) and (params is None)) or
((len(args) > 0) and ((args[0] == "-h") or (args[0] == "--help"))) ):
show_usage()
return
if (params is None):
pcl = iotbx.phil.process_command_line_with_files(
args=args,
master_phil_string=master_phil_str,
pdb_file_def="file_name")
work_params = pcl.work.extract()
# or use parameters defined by GUI
else:
work_params = params
pdb_inp = iotbx.pdb.input(file_name=work_params.file_name)
pdb_int_params = mmtbx.model.manager.get_default_pdb_interpretation_params()
pdb_int_params.pdb_interpretation.clash_guard.nonbonded_distance_threshold=None
model = mmtbx.model.manager(
model_input = pdb_inp,
pdb_interpretation_params = pdb_int_params,
build_grm = True)
else:
work_params = params
if params is None:
work_params = master_phil.extract()
result = mmtbx.refinement.real_space.fit_residues.run(
pdb_hierarchy = model.get_hierarchy(),
crystal_symmetry = model.crystal_symmetry(),
map_data = None,
rotamer_manager = mmtbx.idealized_aa_residues.rotamer_manager.load(
rotamers="favored_allowed"),
sin_cos_table = scitbx.math.sin_cos_table(n=10000),
backbone_sample = False,
rotatable_hd = model.rotatable_hd_selection(iselection=False),
mon_lib_srv = model.get_mon_lib_srv(),
log = out)
model.set_sites_cart(
sites_cart = result.pdb_hierarchy.atoms().extract_xyz(),
update_grm = False)
res_pdb_str = model.model_as_pdb()
with open("%s.pdb" % work_params.output_prefix, "w") as f:
f.write(res_pdb_str)
return model
def run(
pdb_filename=None,
raw_records=None,
return_formal_charges=False,
verbose=False,
):
if pdb_filename:
# Read file into pdb_input class
inp = iotbx.pdb.input(file_name=pdb_filename)
elif raw_records:
inp = iotbx.pdb.input(lines=raw_records, source_info='lines from PDB')
else:
assert 0
# create a model manager
from io import StringIO
log = StringIO()
default_scope = mmtbx.model.manager.get_default_pdb_interpretation_scope()
working_params = default_scope.extract()
# optional???
working_params.pdb_interpretation.automatic_linking.link_metals = True
model = mmtbx.model.manager(
model_input=inp,
log=log,
)
model.process(make_restraints=True,
pdb_interpretation_params=working_params)
# get xray structure
xrs = model.get_xray_structure()
grm = model.get_restraints_manager()
t0 = time.time()
atom_valences = electron_distribution(
model.get_hierarchy(), # needs to be altloc free
model.get_restraints_manager().geometry,
verbose=verbose,
)
if verbose: print(atom_valences)
total_charge = atom_valences.get_total_charge()
#print 'total_charge',total_charge
#print 'time %0.1f' % (time.time()-t0)
rc = atom_valences.validate_atomic_formal_charges()
if return_formal_charges: return atom_valences
return total_charge
# get number of atoms in the input model
n_atoms = model.get_number_of_atoms()
# extract atom coordinates
old_sites_cart = model.get_sites_cart()
# generate random additions
random_addition = flex.vec3_double(
flex.random_double(size=n_atoms * 3) - 0.5)
# actually add them to old coordinates
new_xyz = old_sites_cart + random_addition
# Update coordinates in model manager
model.set_sites_cart(sites_cart=new_xyz)
# reset B-factors (min=1, max=20)
# generate array of new B-factors
new_b = flex.random_double(size=n_atoms, factor=19) + 1
# set them in xray structure
xrs.set_b_iso(values=new_b)
# update model manager with this xray structure
model.set_xray_structure(xrs)
# output result in PDB format to the screen
print(model.model_as_pdb())
print("END")
def run(args, log=sys.stdout):
print >> log, "-" * 79
print >> log, legend
print >> log, "-" * 79
inputs = mmtbx.utils.process_command_line_args(
args=args, master_params=master_params())
params = inputs.params.extract()
# estimate resolution
d_min = params.resolution
broadcast(m="Map resolution:", log=log)
if (d_min is None):
raise Sorry("Resolution is required.")
print >> log, " d_min: %6.4f" % d_min
# model
broadcast(m="Input PDB:", log=log)
file_names = inputs.pdb_file_names
if (len(file_names) != 1): raise Sorry("PDB file has to given.")
if (inputs.crystal_symmetry is None):
raise Sorry("No crystal symmetry defined.")
pdb_inp = iotbx.pdb.input(file_name=file_names[0])
model = mmtbx.model.manager(model_input=pdb_inp,
crystal_symmetry=inputs.crystal_symmetry,
build_grm=True)
if model.get_number_of_models() > 1:
raise Sorry("Only one model allowed.")
model.setup_scattering_dictionaries(
scattering_table=params.scattering_table)
model.get_xray_structure().show_summary(f=log, prefix=" ")
broadcast(m="Input map:", log=log)
if (inputs.ccp4_map is None): raise Sorry("Map file has to given.")
inputs.ccp4_map.show_summary(prefix=" ")
map_data = inputs.ccp4_map.map_data()
print >> log, " Actual map (min,max,mean):", \
map_data.as_1d().min_max_mean().as_tuple()
make_sub_header("Histogram of map values", out=log)
md = map_data.as_1d()
show_histogram(data=md,
n_slots=10,
data_min=flex.min(md),
data_max=flex.max(md),
log=log)
# shift origin if needed
soin = maptbx.shift_origin_if_needed(
map_data=map_data,
sites_cart=model.get_sites_cart(),
crystal_symmetry=model.crystal_symmetry())
map_data = soin.map_data
model.set_sites_cart(soin.sites_cart, update_grm=True)
####
# Compute and show all stats
####
broadcast(m="Model statistics:", log=log)
make_sub_header("Overall", out=log)
info = mmtbx.model.statistics.info(model=model)
info.geometry.show()
# XXX - these are not available anymore due to refactoring
# make_sub_header("Histogram of devations from ideal bonds", out=log)
# show_histogram(data=ms.bond_deltas, n_slots=10, data_min=0, data_max=0.2,
# log=log)
# #
# make_sub_header("Histogram of devations from ideal angles", out=log)
# show_histogram(data=ms.angle_deltas, n_slots=10, data_min=0, data_max=30.,
# log=log)
# #
# make_sub_header("Histogram of non-bonded distances", out=log)
# show_histogram(data=ms.nonbonded_distances, n_slots=10, data_min=0,
# data_max=5., log=log)
#
make_sub_header("Histogram of ADPs", out=log)
info.adp.show(log=log)
# bs = xrs.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
# show_histogram(data=bs, n_slots=10, data_min=flex.min(bs),
# data_max=flex.max(bs), log=log)
#
# Compute CC
broadcast(m="Map-model CC (overall):", log=log)
five_cc_result = mmtbx.maps.correlation.five_cc(
map=map_data, xray_structure=model.get_xray_structure(), d_min=d_min)
atom_radius = five_cc_result.atom_radius
if atom_radius is None:
atom_radius = five_cc_result._atom_radius()
print >> log, " CC_mask : %6.4f" % five_cc_result.result.cc_mask
print >> log, " CC_volume: %6.4f" % five_cc_result.result.cc_volume
print >> log, " CC_peaks : %6.4f" % five_cc_result.result.cc_peaks
# Compute FSC(map, model)
broadcast(m="Model-map FSC:", log=log)
fsc = mmtbx.maps.correlation.fsc_model_vs_map(
xray_structure=model.get_xray_structure(),
map=map_data,
atom_radius=atom_radius,
d_min=d_min)
fsc.show(prefix=" ")
# Local CC
cc_calculator = mmtbx.maps.correlation.from_map_and_xray_structure_or_fmodel(
xray_structure=model.get_xray_structure(),
map_data=map_data,
d_min=d_min)
broadcast(m="Map-model CC (local):", log=log)
# per residue
print >> log, "Per residue:"
residue_results = list()
ph = model.get_hierarchy()
xrs = model.get_xray_structure()
for rg in ph.residue_groups():
cc = cc_calculator.cc(selection=rg.atoms().extract_i_seq())
chain_id = rg.parent().id
print >> log, " chain id: %s resid %s: %6.4f" % (chain_id, rg.resid(),
cc)
# per chain
print >> log, "Per chain:"
for chain in ph.chains():
print >> log, " chain %s: %6.4f" % (
chain.id,
cc_calculator.cc(selection=chain.atoms().extract_i_seq()))
# per residue detailed counts
print >> log, "Per residue (histogram):"
crystal_gridding = maptbx.crystal_gridding(
unit_cell=xrs.unit_cell(),
space_group_info=xrs.space_group_info(),
pre_determined_n_real=map_data.accessor().all())
f_calc = xrs.structure_factors(d_min=d_min).f_calc()
fft_map = miller.fft_map(crystal_gridding=crystal_gridding,
fourier_coefficients=f_calc)
fft_map.apply_sigma_scaling()
map_model = fft_map.real_map_unpadded()
sites_cart = xrs.sites_cart()
cc_per_residue = flex.double()
for rg in ph.residue_groups():
cc = mmtbx.maps.correlation.from_map_map_atoms(
map_1=map_data,
map_2=map_model,
sites_cart=sites_cart.select(rg.atoms().extract_i_seq()),
unit_cell=xrs.unit_cell(),
radius=2.)
cc_per_residue.append(cc)
show_histogram(data=cc_per_residue,
n_slots=10,
data_min=-1.,
data_max=1.0,
log=log)
def stats(model, prefix, no_ticks=True):
# Get rid of H, multi-model, no-protein and single-atom residue models
if (model.percent_of_single_atom_residues() > 20):
return None
sel = model.selection(string="protein")
if (sel.count(True) == 0):
return None
ssr = "protein and not (element H or element D or resname UNX or resname UNK or resname UNL)"
sel = model.selection(string=ssr)
model = model.select(sel)
if (len(model.get_hierarchy().models()) > 1):
return None
# Add H; this looses CRYST1 !
rr = run_reduce_with_timeout(
stdin_lines=model.get_hierarchy().as_pdb_string().splitlines(),
file_name=None,
parameters="-oh -his -flip -keep -allalt -pen9999 -",
override_auto_timeout_with=None)
# Create model; this is a single-model pure protein with new H added
pdb_inp = iotbx.pdb.input(source_info=None, lines=rr.stdout_lines)
model = mmtbx.model.manager(model_input=None,
build_grm=True,
pdb_hierarchy=pdb_inp.construct_hierarchy(),
process_input=True,
log=null_out())
box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center(
sites_cart=model.get_sites_cart(), buffer_layer=5)
model.set_sites_cart(box.sites_cart)
model._crystal_symmetry = box.crystal_symmetry()
#
N = 10
SS = get_ss_selections(hierarchy=model.get_hierarchy())
HB_all = find(
model=model.select(flex.bool(model.size(), True)),
a_DHA_cutoff=90).get_params_as_arrays(replace_with_empty_threshold=N)
HB_alpha = find(
model=model.select(SS.both.h_sel),
a_DHA_cutoff=90).get_params_as_arrays(replace_with_empty_threshold=N)
HB_beta = find(
model=model.select(SS.both.s_sel),
a_DHA_cutoff=90).get_params_as_arrays(replace_with_empty_threshold=N)
print(HB_all.d_HA.size())
result_dict = {}
result_dict["all"] = HB_all
result_dict["alpha"] = HB_alpha
result_dict["beta"] = HB_beta
# result_dict["loop"] = get_selected(sel=loop_sel)
# Load histograms for reference high-resolution d_HA and a_DHA
pkl_fn = libtbx.env.find_in_repositories(
relative_path="mmtbx") + "/nci/d_HA_and_a_DHA_high_res.pkl"
assert os.path.isfile(pkl_fn)
ref = easy_pickle.load(pkl_fn)
#
import matplotlib as mpl
mpl.use('Agg')
import matplotlib.pyplot as plt
fig = plt.figure(figsize=(10, 10))
kwargs = dict(histtype='bar', bins=20, range=[1.6, 3.0], alpha=.8)
for j, it in enumerate([["alpha", 1], ["beta", 3], ["all", 5]]):
key, i = it
ax = plt.subplot(int("32%d" % i))
if (no_ticks):
#ax.set_xticks([])
ax.set_yticks([])
if (j in [0, 1]):
ax.tick_params(bottom=False)
ax.set_xticklabels([])
ax.tick_params(axis="x", labelsize=12)
ax.tick_params(axis="y", labelsize=12, left=False, pad=-2)
ax.text(0.98,
0.92,
key,
size=12,
horizontalalignment='right',
transform=ax.transAxes)
HB = result_dict[key]
if HB is None: continue
w1 = np.ones_like(HB.d_HA) / HB.d_HA.size()
ax.hist(HB.d_HA, color="orangered", weights=w1, rwidth=0.3, **kwargs)
#
start, end1, end2 = 0, max(ref.distances[key].vals), \
round(max(ref.distances[key].vals),2)
if (not no_ticks):
plt.yticks([0.01, end1], ["0", end2],
visible=True,
rotation="horizontal")
if (key == "alpha"): plt.ylim(0, end2 + 0.02)
elif (key == "beta"): plt.ylim(0, end2 + 0.02)
elif (key == "all"): plt.ylim(0, end2 + 0.02)
else: assert 0
#
if (j == 0): ax.set_title("Distance", size=15)
bins = list(flex.double(ref.distances[key].bins))
ax.bar(bins, ref.distances[key].vals, alpha=.3, width=0.07)
#
kwargs = dict(histtype='bar', bins=20, range=[90, 180], alpha=.8)
for j, it in enumerate([["alpha", 2], ["beta", 4], ["all", 6]]):
key, i = it
ax = plt.subplot(int("32%d" % i))
if (j in [0, 1]):
ax.tick_params(bottom=False)
ax.set_xticklabels([])
if (no_ticks):
#ax.set_xticks([])
ax.set_yticks([])
ax.tick_params(axis="x", labelsize=12)
ax.tick_params(axis="y", labelsize=12, left=False, pad=-2)
ax.text(0.98,
0.92,
key,
size=12,
horizontalalignment='right',
transform=ax.transAxes)
ax.text(0.98,
0.92,
key,
size=12,
horizontalalignment='right',
transform=ax.transAxes)
#if(j in [0,1]): ax.plot_params(bottom=False)
HB = result_dict[key]
if HB is None: continue
w1 = np.ones_like(HB.a_DHA) / HB.a_DHA.size()
ax.hist(HB.a_DHA, color="orangered", weights=w1, rwidth=0.3, **kwargs)
#
start, end1, end2 = 0, max(ref.angles[key].vals), \
round(max(ref.angles[key].vals),2)
if (not no_ticks):
plt.yticks([0.01, end1], ["0", end2],
visible=True,
rotation="horizontal")
if (key == "alpha"): plt.ylim(0, end2 + 0.02)
elif (key == "beta"): plt.ylim(0, end2 + 0.02)
elif (key == "all"): plt.ylim(0, end2 + 0.02)
else: assert 0
#
if (j == 0): ax.set_title("Angle", size=15)
ax.bar(ref.angles[key].bins, ref.angles[key].vals, width=4.5, alpha=.3)
plt.subplots_adjust(wspace=0.12, hspace=0.025)
if (no_ticks):
plt.subplots_adjust(wspace=0.025, hspace=0.025)
#fig.savefig("%s.png"%prefix, dpi=1000)
fig.savefig("%s.pdf" % prefix)
