IMP  2.0.1
The Integrative Modeling Platform
IMP::em Namespace Reference

See IMP.em Overview for more information.

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  EnvelopeFitRestraint
 A restraint for envelope-based scoring of particles in the density map. More...
 
class  EnvelopePenetrationRestraint
 Calculate score based on fit to EM map. More...
 
class  EnvelopeScore
 class for envelope based scoring using MapDistanceTransform 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  MapDistanceTransform
 Class for getting the distance from the map envelope. More...
 
class  MapReaderWriter
 The base class to handle reading and writing of density maps. More...
 
class  MRCReaderWriter
 
class  PCAAligner
 
class  PCAFitRestraint
 Calculate score based on fit to EM map. More...
 
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 IMP::base::Vector
< IMP::base::Pointer
< DensityMap > > 
DensityMaps
 rotate a grid More...
 
typedef double emreal
 
typedef IMP::base::Vector
< FittingSolutions
FittingSolutionsList
 
typedef IMP::base::Vector
< KernelParameters
KernelParametersList
 
typedef IMP::base::Vector
< RadiusDependentKernelParameters
RadiusDependentKernelParametersList
 
typedef IMP::base::Vector
< IMP::base::Pointer
< SampledDensityMap > > 
SampledDensityMaps
 
typedef IMP::base::Vector
< IMP::base::Pointer
< SurfaceShellDensityMap > > 
SurfaceShellDensityMaps
 

Enumerations

enum  KernelType { GAUSSIAN, BINARIZED_SPHERE, SPHERE }
 

Functions

Float approximate_molecular_mass (DensityMap *m, Float threshold)
 
DensityMapbinarize (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())
 Compute fitting scores for a given set of rigid transformations. More...
 
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. More...
 
FittingSolutions compute_fitting_scores (DensityMap *em_map, core::RigidBody rb, Refiner *refiner, const algebra::Transformation3Ds &transformations)
 Compute fitting scores for a given set of rigid transformations. More...
 
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.
 
DensityMapcreate_density_map (const DensityMap *other)
 create a copy of another map
 
DensityMapcreate_density_map (const algebra::BoundingBox3D &bb, double spacing)
 Create an empty density map from a boudning box.
 
DensityMapcreate_density_map (int nx, int ny, int nz, double spacing)
 Create an empty density map.
 
DensityMapcreate_density_map (const algebra::GridD< 3, algebra::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. More...
 
algebra::Vector3Ds density2vectors (DensityMap *dmap, Float threshold)
 Converts a density grid to a set of paritlces. More...
 
void DensityHeader_to_ImageHeader (const DensityHeader &header, ImageHeader &h)
 
double EXP (float y)
 
DensityMapget_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)
 
std::string get_data_path (std::string file_name)
 Return the full path to installed data. More...
 
double get_density (const DensityMap *m, const algebra::Vector3D &v)
 
std::string get_example_path (std::string file_name)
 Return the path to installed example data for this module. More...
 
algebra::GridD
< 3, algebra::DenseGridStorageD
< 3, float >, float > 
get_grid (DensityMap *in_map)
 
bool get_interiors_intersect (const DensityMap *d1, const DensityMap *d2)
 
DensityMapget_max_map (DensityMaps maps)
 
Float get_molecular_mass_at_threshold (DensityMap *m, Float threshold, atom::ProteinDensityReference ref=atom::HARPAZ)
 Compute an approximate molecular mass. More...
 
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. More...
 
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. More...
 
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. More...
 
DensityMapget_resampled (DensityMap *input, double scaling)
 Get a resampled version of the map. More...
 
DensityMapget_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. More...
 
DensityMapget_segment (DensityMap *map_to_segment, algebra::Vector3Ds vecs, float dist)
 Get a segment of the map covered by the input points.
 
DensityMapget_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. More...
 
Float get_threshold_for_approximate_volume (DensityMap *m, Float desired_volume)
 Computes the threshold consider in an EM map to get a desired volume. More...
 
DensityMapget_threshold_map (DensityMap *orig_map, float threshold)
 
DensityMapget_transformed (const DensityMap *input, const algebra::Transformation3D &tr, double threshold)
 
DensityMapget_transformed (DensityMap *input, const algebra::Transformation3D &tr)
 
void get_transformed_into (const DensityMap *source, const algebra::Transformation3D &tr, DensityMap *into, bool calc_rms=true)
 Rotate a density map into another map. More...
 
void get_transformed_into2 (const DensityMap *source, const algebra::Transformation3D &tr, DensityMap *into)
 
Float get_volume_at_threshold (DensityMap *m, Float threshold)
 Compute an approximate volume. More...
 
void ImageHeader_to_DensityHeader (const ImageHeader &h, DensityHeader &header)
 
DensityMapinterpolate_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. More...
 
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. More...
 
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. More...
 
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. More...
 
DensityMapmask_and_norm (em::DensityMap *dmap, em::DensityMap *mask)
 
DensityMapmultiply (const DensityMap *m1, const DensityMap *m2)
 
SampledDensityMapparticles2binarized_density (const ParticlesTemp &ps, Float resolution, Float apix, int sig_cutoff=3, const FloatKey &weight_key=IMP::atom::Mass::get_mass_key())
 
SampledDensityMapparticles2density (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. More...
 
SurfaceShellDensityMapparticles2surface (const ParticlesTemp &ps, Float apix, const FloatKey &weight_key=IMP::atom::Mass::get_mass_key())
 Resample a set of particles into a density grid. More...
 
DensityMapread_map (std::string filename, MapReaderWriter *reader)
 
DensityMapread_map (std::string filename)
 
void write_map (DensityMap *m, std::string filename, MapReaderWriter *writer)
 
void write_map (DensityMap *m, std::string filename)
 
def write_pca_cmm
 Write out principal components to a file in Chimera Marker format.
 

Variables

const double EPS = 1e-16
 

Standard module methods

All IMP modules have a set of standard methods to help get information about the module and about files associated with the module.

std::string get_module_version ()
 
std::string get_module_name ()
 

Typedef Documentation

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

Note
this is a low resolution operation. IMPEMEXPORT DensityMap* rotate_grid(const DensityMap *orig_dens, const algebra::Transformation3D &trans);Store a set of objects.

Definition at line 537 of file DensityMap.h.

Pass or store a set of FittingSolutions .

Definition at line 99 of file rigid_fitting.h.

Pass or store a set of KernelParameters .

Definition at line 139 of file KernelParameters.h.

Store a set of objects.

Definition at line 132 of file SampledDensityMap.h.

Function Documentation

Float IMP::em::approximate_molecular_mass ( DensityMap *  m,
Float  threshold 
)
Parameters
[in]ma density map
[in]thresholdconsider 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_mapthe map to binarize
[in]thresholdvalues below the threshold are set to 0 and 1 otherwise
[in]reverseif 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() 
)

Scores how well a set of particles fit a map

Parameters
[in]psThe particles to be fitted
[in]em_mapThe density map to fit to
[in]wei_keyThe 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() 
)

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

Parameters
[in]psThe particles to be fitted (treated rigid)
[in]em_mapThe density map to fit to
[in]wei_keyThe weight key of the particles in the rigid body
[in]fast_versionIf 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]transformationsA set of rigid transformations
[in]fast_versionif true the density map of each transformation is interpolated
[in]local_scoreif 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 
)

Score how well a rigid body fits to the map

Parameters
[in]em_mapThe density map to fit to
[in]rbThe rigid body
[in]refinerThe rigid body refiner
[in]transformationsTransformations of the rigid body
Returns
The scored fitting solutions
Note
the function assumes the density map holds its density

Definition at line 284 of file rigid_fitting.h.

+ Here is the call graph for this function:

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.

DensityMap* IMP::em::create_density_map ( const algebra::GridD< 3, algebra::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 
)

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

Parameters
[in]dmapthe density map
[in]thresholdonly voxels with density above the given threshold will be converted to particles
[in]mmodel to store the new particles
[in]stepsample every X steps in each direction
Returns
particles corresponding to all voxels above the threshold
algebra::Vector3Ds IMP::em::density2vectors ( DensityMap *  dmap,
Float  threshold 
)

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

Parameters
[in]dmapthe density map
[in]thresholdonly 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

algebra::BoundingBoxD<3> IMP::em::get_bounding_box ( const DensityMap *  m,
Float  threshold 
)
Parameters
[in]ma density map
[in]thresholdfind the boudning box for voxels with value above the threshold
std::string IMP::em::get_data_path ( std::string  file_name)

Each module has its own data directory, so be sure to use the version of this function in the correct module. To read the data file "data_library" that was placed in the data directory of module "mymodule", do something like

std::ifstream in(IMP::mymodule::get_data_path("data_library"));

This will ensure that the code works when IMP is installed or used via the tools/imppy.sh script.

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

Return the value for the density map, m, at point v, interpolating linearly from the sample values. The resulting function is C0 over R3.

std::string IMP::em::get_example_path ( std::string  file_name)

Each module has its own example directory, so be sure to use the version of this function in the correct module. For example to read the file example_protein.pdb located in the examples directory of the IMP::atom module, do

IMP::atom::read_pdb(IMP::atom::get_example_path("example_protein.pdb", model));

This will ensure that the code works when IMP is installed or used via the tools/imppy.sh script.

algebra::GridD<3,algebra::DenseGridStorageD<3, float>, float > IMP::em::get_grid ( DensityMap *  in_map)

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 for the set of voxels with intensity
under a given threshold
Parameters
[in]ma density map
[in]thresholdonly voxels above this threshold will be considered
[in]refthe 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 
)

/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 
)

/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 
)

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

DensityMap * get_resampled ( DensityMap *  input,
double  scaling 
)

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 
)
Note
the output map will be cover the region [[nx_start,nx_end],[]ny_start,ny_end,[nz_start,nz_end]]
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
  (only voxels with intensity greater than the threshold are considered)
Parameters
[in]ma density map
[in]desired_mass(in Da)
[in]ref,theprotein 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
  (i.e, the set of voxels with intensity greater than the threshold
  occupies that volume)
Parameters
[in]ma 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_mapthe map to binarize
[in]thresholdvalues below the threshold are set to 0 and 1 otherwise
DensityMap * get_transformed ( const DensityMap *  input,
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 *  input,
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 *  source,
const algebra::Transformation3D &  tr,
DensityMap *  into,
bool  calc_rms = true 
)
Parameters
[in]sourcethe map to transform
[in]trtransform the from density map by this transformation
[out]intothe map to tranform into
[in]calc_rmsif true RMS is calculated on the transformed map
Float IMP::em::get_volume_at_threshold ( DensityMap *  m,
Float  threshold 
)
Compute an approximate volume for the set of voxels with intensity
under a given threshold
Parameters
[in]ma density map
[in]thresholdconsider 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 
)

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]pThe root of the hierarchy to fit
[in]refinerThe refiner to get the leaves of the particle
[in]weight_keyThe weight key of the particles in the rigid body
[in]dmapThe density map to fit to
[in]display_logIf provided, then intermediate states in during the optimization procedure are printed
[in]number_of_optimization_runsnumber of Monte Carlo optimizations
[in]number_of_mc_stepsnumber of steps in a Monte Carlo optimization
[in]number_of_cg_stepsnumber of Conjugate Gradients steps in a Monte Carlo step
[in]max_translationmaximum translation step in a MC optimization step
[in]max_rotationmaximum rotation step in radians in a single MC optimization step
[in]fastif true the density map of the rigid body is not resampled but transformed at each iteration of the optimization
Returns
the refined fitting solutions

Definition at line 167 of file rigid_fitting.h.

+ Here is the call graph for this function:

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 
)

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]pThe rigid body to fit
[in]refinerRefiner to yield rigid body members
[in]weight_keyThe weight key of the particles in the rigid body
[in]dmapThe density map to fit to
[in]anchor_centroidThe point to fit the particles around
[in]display_logIf provided, then intermediate states in during the optimization procedure are printed
[in]number_of_optimization_runsnumber of Monte Carlo optimizations
[in]number_of_mc_stepsnumber of steps in a Monte Carlo optimization
[in]number_of_cg_stepsnumber of Conjugate Gradients steps in a Monte Carlo step
[in]max_translationmaximum translation step in a MC optimization step
[in]max_rotationmaximum rotation step in a single MC optimization step
[in]fastif 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 
)

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]pThe rigid body to fit
[in]refinerRefiner to yield rigid body members
[in]wei_keyThe weight key of the particles in the rigid body
[in]dmapThe density map to fit to
[in]anchor_centroidsThe points to fit the particles around
[in]display_logIf provided, then intermediate states in during the optimization procedure are printed
[in]number_of_optimization_runsnumber of Monte Carlo optimizations
[in]number_of_mc_stepsnumber of steps in a Monte Carlo optimization
[in]number_of_cg_stepsnumber of Conjugate Gradients steps in a Monte Carlo step
[in]max_translationmaximum translation step in a MC optimization step
[in]max_rotationmaximum 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 
)

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]psThe particles to be fitted (treated rigid)
[in]wei_keyThe weight key of the particles in the rigid body
[in]dmapThe density map to fit to
[in]max_voxels_translationSample translations within -max_voxel_translation to max_voxel_translation
[in]translation_stepThe translation sampling step
[in]max_angle_in_radiansSample rotations with +- max_angle_in_radians around the current rotation
[in]number_of_rotationsThe 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]dmapthe density map to mask
[in]maskthe 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 have xyz radius and weight attributes

Parameters
[in]psthe particles to sample
[in]resolutionthe resolution of the new sampled map
[in]apixthe voxel size of the sampled map
[in]sig_cutoffsigma cutoff used in sampling
[in]weight_keythe weight attribute key of the particles
Returns
the sampled density grid

Definition at line 82 of file converters.h.

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

Each such particle should have xyz, radius and weight attributes

Parameters
[in]psthe particles to sample
[in]resolutionthe resolution of the new sampled map
[in]apixthe voxel size of the sampled map
[in]sig_cutoffsigma cutoff used in sampling
[in]weight_keythe 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() 
)

Each such particle should have xyz radius and weight attributes

Parameters
[in]psthe particles to sample
[in]apixthe voxel size of the surface map
[in]weight_keythe 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