def cut_density(mmol=None, mapin=None, radius=1.5, bulk_solvent=True):
log_string = "\n >> clipper_tools: structure_factors"
log_string += "\n bulk_solvent: %s" % bulk_solvent
xml_root = etree.Element('structure_factors')
xml_root.attrib['bulk_solvent'] = str(bulk_solvent)
atoms = mmol.atom_list()
## continue computing a mask when we have faster access to maps/masks
mapout = clipper.Xmap_float()
return log_string, xml_root, mapout
def test_clipper_numpy(self, verbose=False):
'''
Test CCP4MAPfile clipper-python bindings
'''
map_in_path = os.path.join(self.test_data_path, '4x1v_best.map')
assert os.path.exists(map_in_path)
xmap = clipper.Xmap_float()
f = clipper.CCP4MAPfile()
f.open_read(map_in_path)
f.import_xmap_float(xmap)
f.close_read()
sg, samp, cell = f.spacegroup(), f.grid_sampling(), f.cell()
self.assertEquals(sg.symbol_hall(), "P 4cw")
self.assertEquals(sg.symbol_hm(), "P 43")
self.assertEquals(samp.nu(), 90)
self.assertEquals(samp.nv(), 90)
self.assertEquals(samp.nw(), 64)
stats = clipper.Map_stats(xmap)
self.assertAlmostEquals(stats.mean(), 0, places=7)
self.assertAlmostEquals(stats.min(), -0.771, places=3)
self.assertAlmostEquals(stats.max(), 4.557, places=3)
self.assertAlmostEquals(stats.std_dev(), 0.385, places=3)
import sys
import clipper
i = clipper.HKL_reference_index()
xmap = clipper.Xmap_float()
f = clipper.CCP4MAPfile()
f.open_read(sys.argv[1])
f.import_xmap_float(xmap)
f.close_read()
sg, samp, cell = f.spacegroup(), f.grid_sampling(), f.cell()
print sg.symbol_laue()
print sg.symbol_hall()
print cell
print cell.a(), cell.b(), cell.c(), cell.alpha(), cell.beta(), cell.gamma()
print samp.nu(), samp.nv(), samp.nw()
at = clipper.Atom()
at.set_element("H")
# Do not know why this is necessary.
print clipper.ClipperStringAsString(at.element())
stats = clipper.Map_stats(xmap)
print stats.mean(), stats.min(), stats.max(), stats.std_dev()
# Range is unwrapped memory leak, but Range<double> and Range<float> are OK, but require specialized methods.
# There may be a better way, but this works!
print stats.range_double().max()
fphi[ih].phi() = 0.0 ;
}
}
"""
# origin removal
if oremv:
basis_fp = clipper.BasisFn_spline( fphi, nprm, 2.0 );
print basis_fp
target_fp = clipper.TargetFn_meanFnth_F_phi(fphi, 1.0)
oscale = clipper.ResolutionFn( hklp, basis_fp, target_fp, params_init )
"""
for ( HRI ih = fphi.first(); !ih.last(); ih.next() )
if ( !fphi[ih].missing() )
fphi[ih].f() -= oscale.f(ih);
"""
# make grid if necessary
if ( grid.is_null() ):
grid.init( pspgr, cell, reso );
# make xmap
xmap = clipper.Xmap_float( pspgr, cell, grid );
xmap.fft_from_float( fphi );
# write map
mapout = clipper.CCP4MAPfile()
mapout.open_write(opfile)
mapout.export_xmap_float(xmap)
mapout.close_write()
def cut_by_model(mapin="",
pdbin="",
ipradius=1.5,
ipresol=8.0,
ipbfact=0.0,
callback=callbacks.interactive_flush):
xmap = clipper.Xmap_double()
sg = clipper.Spacegroup.p1()
resolution = clipper.Resolution(ipresol)
# create log string so console-based apps get some feedback
log_string = "\n >> clipper_tools: em.cut_density.cut_by_model"
log_string += "\n mapin: %s" % mapin
log_string += "\n pdbin: %s" % pdbin
log_string += "\n bfact: %s" % ipbfact
log_string += "\n resol: %s" % ipresol
log_string += "\n radius: %s" % ipradius
# create XML tree, to be merged in a global structured results file
xml_root = etree.Element('program')
xml_root.attrib['name'] = 'cut_by_model'
xml_root.attrib['user'] = getpass.getuser()
xml_root.attrib['date'] = time.strftime("%c")
params = etree.SubElement(xml_root, 'parameters')
params.attrib['mapin'] = mapin
params.attrib['pdbin'] = pdbin
params.attrib['b_factor'] = str(ipbfact)
params.attrib['resolution'] = str(ipresol)
params.attrib['mask_radius'] = str(ipradius)
callback(log_string, xml_root)
# nothing in, nothing out
if mapin == "" or pdbin == "":
return log_string, xml_root, None
# read the input atomic model
from clipper_tools.io.molecules import read_pdb
log_string_sub, xml_sub, mmol = read_pdb(pdbin)
log_string += log_string_sub
xml_root.append(xml_sub)
callback(log_string, xml_root)
# read the cryoEM map into xmap to get cell dimensions, etc.
from clipper_tools.io.maps import read_xmap
log_sub, xml_sub, xmap = read_xmap(mapin)
log_string += log_sub
xml_root.append(xml_sub)
callback(log_string, xml_root)
grid_sampling = clipper.Grid_sampling(xmap.grid_asu().nu(),
xmap.grid_asu().nv(),
xmap.grid_asu().nw())
log_string += "\n >> cell parameters: %s" % xmap.cell().format()
callback(log_string, xml_root)
# put map content in a numpy data structure
import numpy
map_numpy = numpy.zeros(
(xmap.grid_asu().nu(), xmap.grid_asu().nv(), xmap.grid_asu().nw()),
dtype='double')
log_string += "\n >> exporting a numpy array of %i x %i x %i grid points" \
% (xmap.grid_asu().nu(), xmap.grid_asu().nv(), xmap.grid_asu().nw())
data_points = xmap.export_numpy(map_numpy)
callback(log_string, xml_root)
atom_list = mmol.model().atom_list()
mask = clipper.Xmap_float(xmap.spacegroup(), xmap.cell(), grid_sampling)
masker = clipper.EDcalc_mask_float(ipradius)
masker.compute(mask, atom_list)
mask_matrix = numpy.zeros(
(xmap.grid_asu().nu(), xmap.grid_asu().nv(), xmap.grid_asu().nw()),
dtype='double')
mask_points = mask.export_numpy(mask_matrix)
log_string += "\n >> the original map has %i points and the computed mask has %i points" % (
data_points, mask_points)
callback(log_string, xml_root)
masked_array = map_numpy * mask_matrix
log_string += "\n >> non-zero values: original= %i ; mask=%i ; product=%i" % (
numpy.count_nonzero(map_numpy), numpy.count_nonzero(mask_matrix),
numpy.count_nonzero(masked_array))
xmap.import_numpy(masked_array)
# create HKL_info using user-supplied resolution parameter
hkl_info = clipper.HKL_info(xmap.spacegroup(), xmap.cell(), resolution,
True)
# fft the map
f_phi = clipper.HKL_data_F_phi_float(hkl_info, xmap.cell())
log_string += "\n >> now computing map coefficients to %0.1f A resolution..." % ipresol
callback(log_string, xml_root)
xmap.fft_to(f_phi)
log_string += "\n >> writing map coefficients to MTZ file mapout_cut_density.mtz"
callback(log_string, xml_root)
if ipbfact != 0.0:
f_phi.compute_scale_u_iso_fphi(1.0, clipper.Util.b2u(-ipbfact), f_phi)
log_string += "\n >> and applying B factor correction - using %3.2f\n" % ipbfact
# setup an MTZ file so we can export our map coefficients
from clipper_tools.io.map_coefficients import write_to_mtz
log_sub, xml_sub = write_to_mtz(f_phi, "mapout_cut_density.mtz")
log_string += log_sub
xml_root.append(xml_sub)
log_string += "\n >> all done"
xml_root.attrib['ok'] = 'yes'
callback(log_string, xml_root)
from clipper_tools.callbacks import offline_flush
offline_flush(log_string, xml_root)