IMP::em Namespace Reference

---

Detailed Description

This module allows density maps to be used to generate restraints.

This module provides basic utilities for handling 2D and 3D density maps. The main functionalities are: (1) Reading and writing various density map formts such as XPLOR, MRC, EM and SPIDER. (2) Simulating density maps of particles, supports particles of any radiuii and mass. (3) Calculating cross-correlation scores bewteen a density map and a set of particles.

Examples:

• em examples
• All examples using IMP.em

Author(s): Keren Lasker, Javier Velazquez-Muriel, Friedrich Foerster

Version: SVN.r12662

License: LGPL. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

Publications:

• Daniel Russel, Keren Lasker, Ben Webb, Dina Schneidman, Javier Velázquez-Muriel, Andrej Sali, “Putting the pieces together: integrative structure determination of macromolecular assemblies”, PLoS Biology, 2012. This paper provides an overview of the key concepts in IMP and how to apply them to biological problems.
• Frank Alber, Friedrich Foerster, Dmitry Korkin, Maya Topf, Andrej Sali, “Integrating diverse data for structure determination of macromolecular assemblies”, Annual Review of Biochemistry, 2008. This paper provides a review of the integrative structure determination methodology and various data sources that can be used.

Classes
class	CoarseCC
	Responsible for performing coarse fitting between two density objects. More...
class	CoarseCCatIntervals
	Cross correlation coefficient calculator. More...
class	CoarseConvolution
	Convolutes two grids. More...
class	DensityFillingRestraint
	Calculate score based on fit to EM map. More...
class	DensityHeader
class	DensityMap
	Class for handling density maps. More...
class	DistanceMask
	Calculates and stores a distance mask. More...
class	EnvelopePenetrationRestraint
	Calculate score based on fit to EM map. More...
class	FitRestraint
	Calculate score based on fit to EM map. More...
class	FittingSolutions
	A simple list of fitting solutions. More...
class	HighDensityEmbedding
class	ImageHeader
	Class to deal with the header of Electron Microsocopy images in IMP. More...
class	KernelParameters
class	MapReaderWriter
	The base class to handle reading and writing of density maps. More...
class	MRCReaderWriter
class	RadiusDependentKernelParameters
	Calculates kernel parameters as a function of a specific radius. More...
class	SampledDensityMap
	Class for sampling a density map from particles. More...
struct	SpiderHeader
	Header for Spider images. IMP-EM is designed to be compatible with it. More...
class	SpiderMapReaderWriter
	Class to read EM maps (3D) in Spider and Xmipp formats. More...
class	SurfaceShellDensityMap
	The class repersents a molecule as shells of distance from the surface. More...
class	Voxel
Typedefs
typedef double	emreal
typedef Decorators< Voxel, Particles >	Voxels
Enumerations
enum	KernelType { GAUSSIAN, BINARIZED_SPHERE, SPHERE }
Functions
Float	approximate_molecular_mass (DensityMap *m, Float threshold)
DensityMap *	binarize (DensityMap *orig_map, float threshold, bool reverse=false)
Float	calculate_intersection_score (const SurfaceShellDensityMap *d1, const SurfaceShellDensityMap *d2)
Float	compute_fitting_score (const ParticlesTemp &ps, DensityMap *em_map, FloatKey wei_key=atom::Mass::get_mass_key(), bool local=false)
	Compute fitting scores for a given set of rigid transformations.
FittingSolutions	compute_fitting_scores (const ParticlesTemp &ps, DensityMap *em_map, const algebra::Transformation3Ds &transformations, bool fast_version=false, bool local_score=false, const FloatKey &wei_key=atom::Mass::get_mass_key())
	Compute fitting scores for a given set of rigid transformations.
FittingSolutions	compute_fitting_scores (DensityMap *em_map, core::RigidBody rb, Refiner *refiner, const algebra::Transformation3Ds &transformations, const FloatKey &=atom::Mass::get_mass_key())
	Compute fitting scores for a given set of rigid transformations.
double	convolute (const DensityMap *m1, const DensityMap *m2)
DensityHeader	create_density_header (const algebra::BoundingBoxD< 3 > &bb, float spacing)
	Create a header from a bounding box 3D.
DensityMap *	create_density_map (const DensityMap *other)
	create a copy of another map
DensityMap *	create_density_map (const algebra::BoundingBox3D &bb, double spacing)
	Create an empty density map from a boudning box.
DensityMap *	create_density_map (int nx, int ny, int nz, double spacing)
	Create an empty density map.
DensityMap *	create_density_map (const algebra::grids::GridD< 3, algebra::grids::DenseGridStorageD< 3, float >, float > &grid)
Particles	density2particles (DensityMap *dmap, Float threshold, Model *m, int step=1)
	Converts a density grid to a set of paritlces.
algebra::Vector3Ds	density2vectors (DensityMap *dmap, Float threshold)
	Converts a density grid to a set of paritlces.
void	DensityHeader_to_ImageHeader (const DensityHeader &header, ImageHeader &h)
double	EXP (float y)
DensityMap *	get_binarized_interior (DensityMap *dmap)
	Return a binaries density map with 1 for voxels that are internal.
algebra::BoundingBoxD< 3 >	get_bounding_box (const DensityMap *m, Float threshold)
algebra::BoundingBoxD< 3 >	get_bounding_box (const DensityMap *m)
double	get_density (const DensityMap *m, const algebra::Vector3D &v)
	rotate a grid
algebra::grids::GridD < 3, algebra::grids::DenseGridStorageD < 3, float >, float >	get_grid (DensityMap *in)
bool	get_interiors_intersect (const DensityMap *d1, const DensityMap *d2)
DensityMap *	get_max_map (DensityMaps maps)
Float	get_molecular_mass_at_threshold (DensityMap *m, Float threshold, atom::ProteinDensityReference ref=atom::HARPAZ)
	Compute an approximate molecular mass.
long	get_number_of_particles_outside_of_the_density (DensityMap *dmap, const Particles &ps, const IMP::algebra::Transformation3D &t=IMP::algebra::get_identity_transformation_3d(), float thr=0.0)
	Get the number of particles that are outside of the density.
Ints	get_numbers_of_particles_outside_of_the_density (DensityMap *dmap, const Particles &ps, const IMP::algebra::Transformation3Ds &transformations, float thr=0.0)
	Get numbers of particles (mult transforms) that are outside the density.
double	get_percentage_of_voxels_covered_by_particles (DensityMap *dmap, const Particles &ps, float smoothing_radius=3., const IMP::algebra::Transformation3D &t=IMP::algebra::get_identity_transformation_3d(), float thr=0.0)
	Get the number of density voxels that are not covered by particles.
DensityMap *	get_resampled (DensityMap *in, double scaling)
DensityMap *	get_segment (DensityMap *map_to_segment, int nx_start, int nx_end, int ny_start, int ny_end, int nz_start, int nz_end)
	Get a segment of the map according to xyz indexes.
DensityMap *	get_segment (DensityMap *map_to_segment, algebra::Vector3Ds vecs, float dist)
	Get a segment of the map covered by the input points.
DensityMap *	get_segment_by_masking (DensityMap *map_to_segment, DensityMap *mask, float mas_threshold)
	Get a segment of the map covered by another map.
double	get_sum (const DensityMap *m1)
	Return the sum of all voxels.
Float	get_threshold_for_approximate_mass (DensityMap *m, Float desired_mass, atom::ProteinDensityReference ref=atom::HARPAZ)
	Computes the threshold to consider in an EM map to get a desired mass.
Float	get_threshold_for_approximate_volume (DensityMap *m, Float desired_volume)
	Computes the threshold consider in an EM map to get a desired volume.
DensityMap *	get_threshold_map (DensityMap *orig_map, float threshold)
DensityMap *	get_transformed (const DensityMap *in, const algebra::Transformation3D &tr, double threshold)
DensityMap *	get_transformed (DensityMap *in, const algebra::Transformation3D &tr)
void	get_transformed_into (const DensityMap *from, const algebra::Transformation3D &tr, DensityMap *into, bool calc_rms=true)
	Rotate a density map into another maps.
void	get_transformed_into2 (const DensityMap *from, const algebra::Transformation3D &tr, DensityMap *into)
Float	get_volume_at_threshold (DensityMap *m, Float threshold)
	Compute an approximate volume.
void	ImageHeader_to_DensityHeader (const ImageHeader &h, DensityHeader &header)
DensityMap *	interpolate_map (DensityMap *in_map, double new_spacing)
FittingSolutions	local_rigid_fitting (Particle *p, Refiner *refiner, const FloatKey &weight_key, DensityMap *dmap, OptimizerStates display_log, Int number_of_optimization_runs=5, Int number_of_mc_steps=10, Int number_of_cg_steps=100, Float max_translation=2., Float max_rotation=.3, bool fast=true)
	Local rigid fitting of a rigid body.
FittingSolutions	local_rigid_fitting_around_point (Particle *p, Refiner *refiner, const FloatKey &weight_key, DensityMap *dmap, const algebra::Vector3D &anchor_centroid, OptimizerStates display_log, Int number_of_optimization_runs=5, Int number_of_mc_steps=10, Int number_of_cg_steps=100, Float max_translation=2., Float max_rotation=.3, bool fast=false)
	Local rigid fitting of a rigid body around a center point.
FittingSolutions	local_rigid_fitting_around_points (Particle *p, Refiner *refiner, const FloatKey &wei_key, DensityMap *dmap, const algebra::Vector3Ds &anchor_centroids, OptimizerStates display_log, Int number_of_optimization_runs=5, Int number_of_mc_steps=10, Int number_of_cg_steps=100, Float max_translation=2., Float max_rotation=.3)
	Local rigid fitting of a rigid body around a set of center points.
FittingSolutions	local_rigid_fitting_grid_search (const ParticlesTemp &ps, const FloatKey &wei_key, DensityMap *dmap, Int max_voxels_translation=2, Int translation_step=1, Float max_angle_in_radians=0.174, Int number_of_rotations=100)
	Local grid search rigid fitting.
DensityMap *	mask_and_norm (em::DensityMap *dmap, em::DensityMap *mask)
DensityMap *	multiply (const DensityMap *m1, const DensityMap *m2)
SampledDensityMap *	particles2binarized_density (const ParticlesTemp &ps, Float resolution, Float apix, int sig_cutoff=3, const FloatKey &weight_key=IMP::atom::Mass::get_mass_key())
SampledDensityMap *	particles2density (const ParticlesTemp &ps, Float resolution, Float apix, int sig_cutoff=3, const FloatKey &weight_key=IMP::atom::Mass::get_mass_key())
	Resample a set of particles into a density grid.
SurfaceShellDensityMap *	particles2surface (const ParticlesTemp &ps, Float apix, const FloatKey &weight_key=IMP::atom::Mass::get_mass_key())
	Resample a set of particles into a density grid.
DensityMap *	read_map (std::string filename, MapReaderWriter *reader)
DensityMap *	read_map (std::string filename)
void	write_map (DensityMap *m, std::string filename, MapReaderWriter *writer)
void	write_map (DensityMap *m, std::string filename)
Variables
const double	EPS = 1e-16

---

Function Documentation

Float IMP::em::approximate_molecular_mass	(	DensityMap *	m,
		Float	threshold
	)

Parameters:

[in]	m	a density map
[in]	threshold	consider volume of only voxels above this threshold

Note:

The method assumes 1.21 cubic A per dalton (Harpaz 1994).

DensityMap* IMP::em::binarize	(	DensityMap *	orig_map,
		float	threshold,
		bool	reverse = false
	)

Return a map with 0 for all voxels below the threshold and 1 for thoes above

Parameters:

[in]	orig_map	the map to binarize
[in]	threshold	values below the threshold are set to 0 and 1 otherwise
[in]	reverse	if true values above the threshold are set to 0 and 1 otherwise

Float IMP::em::compute_fitting_score	(	const ParticlesTemp &	ps,
		DensityMap *	em_map,
		FloatKey	wei_key = atom::Mass::get_mass_key(),
		bool	local = false
	)

Compute fitting scores for a given set of rigid transformations.

Scores how well a set of particles fit a map

Parameters:

[in]	ps	The particles to be fitted
[in]	em_map	The density map to fit to
[in]	rad_key	The raidus key of the particles in the rigid body
[in]	wei_key	The weight key of the particles in the rigid body

Note:

the function assumes the density map holds its density

FittingSolutions IMP::em::compute_fitting_scores	(	const ParticlesTemp &	ps,
		DensityMap *	em_map,
		const algebra::Transformation3Ds &	transformations,
		bool	fast_version = false,
		bool	local_score = false,
		const FloatKey &	wei_key = atom::Mass::get_mass_key()
	)

Compute fitting scores for a given set of rigid transformations.

Score how well a set of particles fit to the map in various rigid transformations.

Parameters:

[in]	ps	The particles to be fitted (treated rigid)
[in]	em_map	The density map to fit to
[in]	rad_key	The raidus key of the particles in the rigid body
[in]	wei_key	The weight key of the particles in the rigid body
[in]	fast_version	If fast_version is used the sampled density map of the input particles (ps) is not resampled for each transformation but instead the corresponding grid is rotated. This option significantly improves the running times but the returned scores are less accurate
[in]	transformations	A set of rigid transformations
[in]	fast_version	if true the density map of each transformation is interpolated
[in]	local_score	if true a local cross correlation score is used

Returns:

The scored fitting solutions

Note:

the function assumes the density map holds its density

FittingSolutions IMP::em::compute_fitting_scores	(	DensityMap *	em_map,
		core::RigidBody	rb,
		Refiner *	refiner,
		const algebra::Transformation3Ds &	transformations,
		const FloatKey &	= atom::Mass::get_mass_key()
	)

Compute fitting scores for a given set of rigid transformations.

Score how well a rigid body fits to the map

Parameters:

[in]	em_map	The density map to fit to
[in]	rb	The rigid body
[in]	refiner	The rigid body refiner
[in]	transformations	Transformations of the rigid body
[in]	rad_key	The raidus key of the particles in the rigid body
[in]	wei_key	The weight key of the particles in the rigid body

Returns:

The scored fitting solutions

Note:

the function assumes the density map holds its density

double IMP::em::convolute	(	const DensityMap *	m1,
		const DensityMap *	m2
	)

Return a convolution between density maps m1 and m2. The function assumes m1 and m2 are of the same dimensions.

DensityHeader create_density_header	(	const algebra::BoundingBoxD< 3 > &	bb,
		float	spacing
	)

Create a header from a bounding box 3D.

DensityMap* IMP::em::create_density_map

(

const DensityMap *

other

)

create a copy of another map

DensityMap* IMP::em::create_density_map	(	const algebra::BoundingBox3D &	bb,
		double	spacing
	)

Create an empty density map from a boudning box.

DensityMap* IMP::em::create_density_map	(	int	nx,
		int	ny,
		int	nz,
		double	spacing
	)

Create an empty density map.

DensityMap* IMP::em::create_density_map

(

const algebra::grids::GridD< 3, algebra::grids::DenseGridStorageD< 3, float >, float > &

grid

)

Return a density map with the values taken from the grid.

Particles IMP::em::density2particles	(	DensityMap *	dmap,
		Float	threshold,
		Model *	m,
		int	step = 1
	)

Converts a density grid to a set of paritlces.

Each such particle will be have xyz attributes and a density_val attribute of type Float.

Parameters:

[in]	dmap	the density map
[in]	threshold	only voxels with density above the given threshold will be converted to particles
[in]	m	model to store the new particles
[in]	step	sample every X steps in each direction

Returns:

particles corresponding to all voxels above the threshold

algebra::Vector3Ds IMP::em::density2vectors	(	DensityMap *	dmap,
		Float	threshold
	)

Converts a density grid to a set of paritlces.

Each such particle will be have xyz attributes and a density_val attribute of type Float.

Parameters:

[in]	dmap	the density map
[in]	threshold	only voxels with density above the given threshold will be converted to particles

Returns:

a set of vector3Ds corresponding to the positions of all voxels above the threshold

void IMP::em::DensityHeader_to_ImageHeader	(	const DensityHeader &	header,
		ImageHeader &	h
	)

Function to transfer the (compatible) information content from DensityHeader to ImageHeader

DensityMap* IMP::em::get_binarized_interior

(

DensityMap *

dmap

)

Return a binaries density map with 1 for voxels that are internal.

algebra::BoundingBoxD<3> IMP::em::get_bounding_box	(	const DensityMap *	m,
		Float	threshold
	)

Parameters:

[in]	m	a density map
[in]	threshold	find the boudning box for voxels with value above the threshold

double get_density	(	const DensityMap *	m,
		const algebra::Vector3D &	v
	)

rotate a grid

/param[in] orig_dens the density map to rotate /param[in] trans the transformation

Note:

this is a low resolution operation. DensityMap* rotate_grid(const DensityMap *orig_dens, const algebra::Transformation3D &trans); Return the value for the density map, m, at point v, interpolating linearly from the sample values. The resulting function is C0 over R3.

algebra::grids::GridD<3,algebra::grids::DenseGridStorageD<3, float>, float > IMP::em::get_grid

(

DensityMap *

in

)

Return a dense grid containing the voxels of the passed density map as well as the same bounding box.

DensityMap* IMP::em::get_max_map

(

DensityMaps

maps

)

Return a density map for which each voxel is the maximum value from the input densities.

Note:

all input maps should have the same extent

Float IMP::em::get_molecular_mass_at_threshold	(	DensityMap *	m,
		Float	threshold,
		atom::ProteinDensityReference	ref = atom::HARPAZ
	)

Compute an approximate molecular mass.

Compute an approximate molecular mass for the set of voxels with intensity under a given threshold

Parameters:

[in]	m	a density map
[in]	threshold,only	voxels above this threshold will be considered
[in]	ref,the	protein density reference to use in the computation. The default protein density for this computation is HARPAZ

Returns:

an approximate molecular mass for the set of voxels with intensity under the provided threshold (mass in Da)

long IMP::em::get_number_of_particles_outside_of_the_density	(	DensityMap *	dmap,
		const Particles &	ps,
		const IMP::algebra::Transformation3D &	t = IMP::algebra::get_identity_transformation_3d(),
		float	thr = 0.0
	)

Get the number of particles that are outside of the density.

/note the function assumes that all of the particles have XYZ coordinates

Ints IMP::em::get_numbers_of_particles_outside_of_the_density	(	DensityMap *	dmap,
		const Particles &	ps,
		const IMP::algebra::Transformation3Ds &	transformations,
		float	thr = 0.0
	)

Get numbers of particles (mult transforms) that are outside the density.

/note the function assumes that all of the particles have XYZ coordinates

double IMP::em::get_percentage_of_voxels_covered_by_particles	(	DensityMap *	dmap,
		const Particles &	ps,
		float	smoothing_radius = 3.,
		const IMP::algebra::Transformation3D &	t = IMP::algebra::get_identity_transformation_3d(),
		float	thr = 0.0
	)

Get the number of density voxels that are not covered by particles.

/note the function assumes that all of the particles have XYZ coordinates

DensityMap * get_resampled	(	DensityMap *	in,
		double	scaling
	)

Get a resampled version of the map. The spacing is multiplied by scaling. That means, scaling values greater than 1 increase the voxel size.

DensityMap* IMP::em::get_segment	(	DensityMap *	map_to_segment,
		int	nx_start,
		int	nx_end,
		int	ny_start,
		int	ny_end,
		int	nz_start,
		int	nz_end
	)

Get a segment of the map according to xyz indexes.

Note:

the output map will be cover the region [[nx_start,nx_end],[]ny_start,ny_end,[nz_start,nz_end]]

DensityMap* IMP::em::get_segment	(	DensityMap *	map_to_segment,
		algebra::Vector3Ds	vecs,
		float	dist
	)

Get a segment of the map covered by the input points.

DensityMap* IMP::em::get_segment_by_masking	(	DensityMap *	map_to_segment,
		DensityMap *	mask,
		float	mas_threshold
	)

Get a segment of the map covered by another map.

double IMP::em::get_sum

(

const DensityMap *

m1

)

Return the sum of all voxels.

Float IMP::em::get_threshold_for_approximate_mass	(	DensityMap *	m,
		Float	desired_mass,
		atom::ProteinDensityReference	ref = atom::HARPAZ
	)

Computes the threshold to consider in an EM map to get a desired mass.

Computes the threshold to consider in an EM map to get a desired mass (only voxels with intensity greater than the threshold are considered)

Parameters:

[in]	m	a density map
[in]	desired_mass	(in Da)
[in]	ref,the	protein density reference to use in the computation. The default protein density for this computation is HARPAZ

Float IMP::em::get_threshold_for_approximate_volume	(	DensityMap *	m,
		Float	desired_volume
	)

Computes the threshold consider in an EM map to get a desired volume.

Computes the threshold consider in an EM map to get a desired volume (i.e, the set of voxels with intensity greater than the threshold occupies that volume)

Parameters:

[in]	m	a density map
[in]	desired_volume	(in A^3)

DensityMap* IMP::em::get_threshold_map	(	DensityMap *	orig_map,
		float	threshold
	)

Return a map with 0 for all voxels below the threshold

Parameters:

[in]	orig_map	the map to binarize
[in]	threshold	values below the threshold are set to 0 and 1 otherwise

DensityMap * get_transformed	(	const DensityMap *	in,
		const algebra::Transformation3D &	tr,
		double	threshold
	)

Return a new density map containing a rotated version of the old one. Only voxels whose value is above threshold are considered when computing the bounding box of the new map (set IMP::em::get_bounding_box()).

DensityMap * get_transformed	(	DensityMap *	in,
		const algebra::Transformation3D &	tr
	)

Return a new density map containing a rotated version of the old one. The dimension of the new map is the same as the old one.

void get_transformed_into	(	const DensityMap *	from,
		const algebra::Transformation3D &	tr,
		DensityMap *	into,
		bool	calc_rms = true
	)

Rotate a density map into another maps.

Parameters:

[in]	from	the map to transform
[in]	tr	transform the from density map by this transformation
[out]	into	the map to tranform into
[in]	calc_rms	if true RMS is calculated on the transformed map

Float IMP::em::get_volume_at_threshold	(	DensityMap *	m,
		Float	threshold
	)

Compute an approximate volume.

Compute an approximate volume for the set of voxels with intensity under a given threshold

Parameters:

[in]	m	a density map
[in]	threshold,consider	volume of only voxels above this threshold

Returns:

a volume for the set of voxels with intensity under the provided threshold

void IMP::em::ImageHeader_to_DensityHeader	(	const ImageHeader &	h,
		DensityHeader &	header
	)

Function to transfer the (compatible) information content from ImageHeader to DensityHeader

DensityMap* IMP::em::interpolate_map	(	DensityMap *	in_map,
		double	new_spacing
	)

Return a new map with an updated spacing and interpolate input data accordinly

FittingSolutions IMP::em::local_rigid_fitting	(	Particle *	p,
		Refiner *	refiner,
		const FloatKey &	weight_key,
		DensityMap *	dmap,
		OptimizerStates	display_log,
		Int	number_of_optimization_runs = 5,
		Int	number_of_mc_steps = 10,
		Int	number_of_cg_steps = 100,
		Float	max_translation = 2.,
		Float	max_rotation = .3,
		bool	fast = true
	)

Local rigid fitting of a rigid body.

Fit a set of particles to a density map around their centroid. The fitting is assessed using the cross-correaltion score. The optimization is a standard MC/CG procedure. The function returns a list of solutions sortedo the cross-correlation score.

Note:

The returned cross-correlation score is 1-cc, as we usually want to minimize a scroing function. Thus a score of 1 means no-correlation and a score of 0. is perfect correlation.

The input rigid body should be also IMP::atom::Hierarchy

Parameters:

[in]	p	The root of the hierarchy to fit
[in]	refiner	The refiner to get the leaves of the particle
[in]	weight_key	The weight key of the particles in the rigid body
[in]	dmap	The density map to fit to
[in]	display_log	If provided, then intermediate states in during the optimization procedure are printed
[in]	number_of_optimization_runs	number of Monte Carlo optimizations
[in]	number_of_mc_steps	number of steps in a Monte Carlo optimization
[in]	number_of_cg_steps	number of Conjugate Gradients steps in a Monte Carlo step
[in]	max_translation	maximum translation step in a MC optimization step
[in]	max_rotation	maximum rotation step in radians in a single MC optimization step
[in]	fast	if true the density map of the rigid body is not resampled but transformed at each iteration of the optimization

Returns:

the refined fitting solutions

FittingSolutions IMP::em::local_rigid_fitting_around_point	(	Particle *	p,
		Refiner *	refiner,
		const FloatKey &	weight_key,
		DensityMap *	dmap,
		const algebra::Vector3D &	anchor_centroid,
		OptimizerStates	display_log,
		Int	number_of_optimization_runs = 5,
		Int	number_of_mc_steps = 10,
		Int	number_of_cg_steps = 100,
		Float	max_translation = 2.,
		Float	max_rotation = .3,
		bool	fast = false
	)

Local rigid fitting of a rigid body around a center point.

Fit a set of particles to a density map around an anchor point. The fitting is assessed using the cross-correaltion score. The optimization is a standard MC/CG procedure. The function returns a list of solutions sortedo the cross-correlation score.

Note:

The returned cross-correlation score is 1-cc, as we usually want to minimize a scroing function. Thus a score of 1 means no-correlation and a score of 0. is perfect correlation.

The input rigid body should be also IMP::atom::Hierarchy

Parameters:

[in]	rb	The rigid body to fit
[in]	radius_key	The raidus key of the particles in the rigid body
[in]	weight_key	The weight key of the particles in the rigid body
[in]	dmap	The density map to fit to
[in]	anchor_centroid	The point to fit the particles around
[in]	display_log	If provided, then intermediate states in during the optimization procedure are printed
[in]	number_of_optimization_runs	number of Monte Carlo optimizations
[in]	number_of_mc_steps	number of steps in a Monte Carlo optimization
[in]	number_of_cg_steps	number of Conjugate Gradients steps in a Monte Carlo step
[in]	max_translation	maximum translation step in a MC optimization step
[in]	max_rotation	maximum rotation step in a single MC optimization step
[in]	fast	if true the density map of the rigid body is not resampled but transformed at each iteration of the optimization

Returns:

the refined fitting solutions

FittingSolutions IMP::em::local_rigid_fitting_around_points	(	Particle *	p,
		Refiner *	refiner,
		const FloatKey &	wei_key,
		DensityMap *	dmap,
		const algebra::Vector3Ds &	anchor_centroids,
		OptimizerStates	display_log,
		Int	number_of_optimization_runs = 5,
		Int	number_of_mc_steps = 10,
		Int	number_of_cg_steps = 100,
		Float	max_translation = 2.,
		Float	max_rotation = .3
	)

Local rigid fitting of a rigid body around a set of center points.

Fit a set of particles to a density map around each of the input points. The function apply local_rigid_fitting_around_point around each center.

Note:

The input rigid body should be also IMP::atom::Hierarchy

Parameters:

[in]	rb	The rigid body to fit
[in]	rad_key	The raidus key of the particles in the rigid body
[in]	wei_key	The weight key of the particles in the rigid body
[in]	dmap	The density map to fit to
[in]	anchor_centroids	The points to fit the particles around
[in]	display_log	If provided, then intermediate states in during the optimization procedure are printed
[in]	number_of_optimization_runs	number of Monte Carlo optimizations
[in]	number_of_mc_steps	number of steps in a Monte Carlo optimization
[in]	number_of_cg_steps	number of Conjugate Gradients steps in a Monte Carlo step
[in]	max_translation	maximum translation step in a MC optimization step
[in]	max_rotation	maximum rotation step in a single MC optimization step

Returns:

the refined fitting solutions

FittingSolutions IMP::em::local_rigid_fitting_grid_search	(	const ParticlesTemp &	ps,
		const FloatKey &	wei_key,
		DensityMap *	dmap,
		Int	max_voxels_translation = 2,
		Int	translation_step = 1,
		Float	max_angle_in_radians = 0.174,
		Int	number_of_rotations = 100
	)

Local grid search rigid fitting.

Fit a set of particles to a density map around their centroid. The fitting is assessed using the cross-correaltion score. The optimization is a grid search

Note:

The transformations are not clustered.

The returned cross-correlation score is 1-cc, as we usually want to minimize a scroing function. Thus a score of 1 means no-correlation and a score of 0. is perfect correlation.

Parameters:

[in]	ps	The particles to be fitted (treated rigid)
[in]	rad_key	The raidus key of the particles in the rigid body
[in]	wei_key	The weight key of the particles in the rigid body
[in]	dmap	The density map to fit to
[in]	max_voxels_translation	Sample translations within -max_voxel_translation to max_voxel_translation
[in]	translation_step	The translation sampling step
[in]	max_angle_in_radians	Sample rotations with +- max_angle_in_radians around the current rotation
[in]	number_of_rotations	The number of rotations to sample

Returns:

the refined fitting solutions

DensityMap* IMP::em::mask_and_norm	(	em::DensityMap *	dmap,
		em::DensityMap *	mask
	)

Return a masked density , and normalize the output map within the masked region

Parameters:

[in]	dmap	the density map to mask
[in]	mask	the mask

Returns:

the masked and normalized map

DensityMap* IMP::em::multiply	(	const DensityMap *	m1,
		const DensityMap *	m2
	)

Return a density map for which voxel i contains the result of m1[i]*m2[i]. The function assumes m1 and m2 are of the same dimensions.

SampledDensityMap * particles2binarized_density	(	const ParticlesTemp &	ps,
		Float	resolution,
		Float	apix,
		int	sig_cutoff = 3,
		const FloatKey &	weight_key = IMP::atom::Mass::get_mass_key()
	)

Resample a set of particles into a binarized density map 1 for voxels containing particles and 0 otherwise Each such particle should be have xyz radius and weight attributes

Parameters:

[in]	ps	the particles to sample
[in]	resolution	the resolution of the new sampled map
[in]	apix	the voxel size of the sampled map
[in]	sig_cutoff	sigma cutoff used in sampling
[in]	rad_key	the radius attribute key of the particles
[in]	weight_key	the weight attribute key of the particles

Returns:

the sampled density grid

SampledDensityMap * particles2density	(	const ParticlesTemp &	ps,
		Float	resolution,
		Float	apix,
		int	sig_cutoff = 3,
		const FloatKey &	weight_key = IMP::atom::Mass::get_mass_key()
	)

Resample a set of particles into a density grid.

Each such particle should be have xyz radius and weight attributes

Parameters:

[in]	ps	the particles to sample
[in]	resolution	the resolution of the new sampled map
[in]	apix	the voxel size of the sampled map
[in]	sig_cutoff	sigma cutoff used in sampling
[in]	rad_key	the radius attribute key of the particles
[in]	weight_key	the weight attribute key of the particles

Returns:

the sampled density grid

SurfaceShellDensityMap * particles2surface	(	const ParticlesTemp &	ps,
		Float	apix,
		const FloatKey &	weight_key = IMP::atom::Mass::get_mass_key()
	)

Resample a set of particles into a density grid.

Each such particle should be have xyz radius and weight attributes

Parameters:

[in]	ps	the particles to sample
[in]	apix	the voxel size of the surface map
[in]	rad_key	the radius attribute key of the particles
[in]	weight_key	the weight attribute key of the particles

Returns:

the surface grid

DensityMap * read_map	(	std::string	filename,
		MapReaderWriter *	reader
	)

Read a density map from a file and return it.

DensityMap * read_map

(

std::string

filename

)

Read a density map from a file and return it. Guess the file type from the file name. The file formats supported are:

• .mrc
• .em
• .vol
• .xplor

void write_map	(	DensityMap *	m,
		std::string	filename,
		MapReaderWriter *	writer
	)

Write a density map to a file.

void write_map	(	DensityMap *	m,
		std::string	filename
	)

Write a density map to a file. Guess the file type from the file name. The file formats supported are:

• .mrc
• .em
• .vol
• .xplor