IMP::example Namespace Reference

Example module. More...

Detailed Description

Example module.

This module contains simple classes that span many parts of IMP functionality, so it can be used to see how to write a new class, export it to Python, document it, and provide tests and examples.

The overview section of the module page can contain any MarkDown or doxygen markup as well as references to IMP classes such as IMP::Model.

imp_example_app

This is an example application (command line tool).

Info

Author(s): Daniel Russel

Maintainer: benmwebb

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:

• See main IMP papers list.

Classes
class	ExampleComplexRestraint
	Restrain the diameter of a set of points. More...
class	ExampleConstraint
	A trivial constraint that just increments a counter. More...
class	ExampleDecorator
	A simple decorator which adds a name to a particle. More...
class	ExampleObject
	An example simple object which is reference counted. More...
class	ExamplePairScore
	Apply a harmonic to the distance between two particles. More...
class	ExampleRestraint
	Restrain a particle to be in the x,y plane. More...
class	ExampleSingletonModifier
	An example singleton modifier. More...
class	ExampleSubsetFilterTable
class	ExampleTemplateClassD
	A line segment templated on the dimension. More...
class	ExampleUnaryFunction
	A simple unary function. More...
class	PythonExampleConstraint
	An example Constraint written in Python. More...
class	PythonExamplePairScore
	An example PairScore written in Python. More...
class	PythonExampleRestraint
	An example restraint written in Python. More...
class	PythonExampleSingletonModifier
	An example SingletonModifier written in Python. More...
class	PythonExampleUnaryFunction
	An example UnaryFunction written in Python. More...

Typedefs
typedef IMP::Vector < ExampleDecorator >	ExampleDecorators
typedef Vector< Pointer < ExampleObject > >	ExampleObjects
typedef Vector< WeakPointer < ExampleObject > >	ExampleObjectsTemp
typedef IMP::Vector < IMP::Pointer < ExamplePairScore > >	ExamplePairScores
typedef IMP::Vector < IMP::WeakPointer < ExamplePairScore > >	ExamplePairScoresTemp
typedef ExampleTemplateClassD< 3 >	ExampleTemplateClass3D
typedef Vector < ExampleTemplateClassD< 3 > >	ExampleTemplateClass3Ds

Functions
Restraint *	create_chain_restraint (Model *m, const ParticleIndexes &ps, double length_factor, double k, std::string name)
Restraint *	create_excluded_volume (const ParticlesTemp &ps, double k, std::string name)
core::MonteCarloMover *	create_serial_mover (Model *m, const ParticleIndexes &pis)
unsigned int	get_number_of_incidences (const ParticlesTemp &psa, const ParticlesTemp &psb, double point_distance)
void	optimize_assembly (Model *m, const ParticleIndexes &components, const RestraintsTemp &interactions, const RestraintsTemp &other_restraints, const algebra::BoundingBox3D &bb, PairScore *ev, double cutoff, const PairPredicates &excluded=PairPredicates())
void	optimize_balls (Model *m, const ParticleIndexes &pis, const RestraintsTemp &rs=RestraintsTemp(), const PairPredicates &excluded=PairPredicates(), const OptimizerStates &opt_states=OptimizerStates(), LogLevel ll=DEFAULT)
template<class ParticlesList , class BoundingVolume >
void	randomize_particles (const ParticlesList &ps, const BoundingVolume &bv)
template<class RigidBody , class BoundingVolume >
void	randomize_rigid_body (RigidBody rbi, const BoundingVolume &bv)

Standard module functions
All IMP modules have a set of standard functions to help get information about the module and about files associated with the module.
std::string	get_module_version ()
std::string	get_module_name ()
std::string	get_data_path (std::string file_name)
	Return the full path to one of this module's data files. More...
std::string	get_example_path (std::string file_name)
	Return the full path to one of this module's example files. More...

Typedef Documentation

typedef IMP::Vector<IMP::Pointer< ExamplePairScore > > IMP::example::ExamplePairScores

A vector of reference-counting object pointers.

Definition at line 40 of file ExamplePairScore.h.

typedef IMP::Vector<IMP::WeakPointer< ExamplePairScore > > IMP::example::ExamplePairScoresTemp

A vector of weak (non reference-counting) pointers to specified objects.

See Also

ExamplePairScore

Definition at line 40 of file ExamplePairScore.h.

Function Documentation

Restraint* IMP::example::create_chain_restraint	(	Model *	m,
		const ParticleIndexes &	ps,
		double	length_factor,
		double	k,
		std::string	name
	)

Restrain the passed particles to be connected in a chain. The distance between consecutive particles is length_factor*the sum of the radii.

Note, this assumes that all such chains will be disjoint and so you can use the container::ExclusiveConsecutivePairFilter if you want to filter out all pairs of particles connected by such chain restraints.

The restraint is not added to the model.

Definition at line 31 of file creating_restraints.h.

Here is the call graph for this function:

Restraint* IMP::example::create_excluded_volume	(	const ParticlesTemp &	ps,
		double	k,
		std::string	name
	)

Create an excluded-volume style ClosePairsContainer based score.

Definition at line 50 of file creating_restraints.h.

Here is the call graph for this function:

core::MonteCarloMover* IMP::example::create_serial_mover	(	Model *	m,
		const ParticleIndexes &	pis
	)

Create a serial mover from a list of core::XYZR particles.

std::string IMP::example::get_data_path

(

std::string

file_name

)

Return the full path to one of this module's data files.

To read the data file "data_library" that was placed in the data directory of this module, do something like

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

This will ensure that the code works both when IMP is installed or if used via the setup_environment.sh script.

Note

Each module has its own data directory, so be sure to use this function from the correct module.

std::string IMP::example::get_example_path

(

std::string

file_name

)

Return the full path to one of this module's example files.

To read the example file "example_protein.pdb" that was placed in the examples directory of this module, do something like

std::ifstream in(IMP::example::get_example_path("example_protein.pdb"));

This will ensure that the code works both when IMP is installed or if used via the setup_environment.sh script.

Note

Each module has its own example directory, so be sure to use this function from the correct module.

unsigned int IMP::example::get_number_of_incidences	(	const ParticlesTemp &	psa,
		const ParticlesTemp &	psb,
		double	point_distance
	)

Return the number of times particles from one set are close to those from another set.

Note

This method uses the distance between the centers of the particles and does not use their radii.

Definition at line 23 of file counting.h.

Here is the call graph for this function:

void IMP::example::optimize_assembly	(	Model *	m,
		const ParticleIndexes &	components,
		const RestraintsTemp &	interactions,
		const RestraintsTemp &	other_restraints,
		const algebra::BoundingBox3D &	bb,
		PairScore *	ev,
		double	cutoff,
		const PairPredicates &	excluded = PairPredicates()
	)

Provide an example of a more involved protocol for assembly a complex. The protocol adds the particles one at a time based on how well connected they are to the already added particles (in the interaction graph). After each addition, the assembly is optimized. The protocol seems to work at assembling the residues of a protein from a truncated distance matrix.

void IMP::example::optimize_balls	(	Model *	m,
		const ParticleIndexes &	pis,
		const RestraintsTemp &	rs = RestraintsTemp(),
		const PairPredicates &	excluded = PairPredicates(),
		const OptimizerStates &	opt_states = OptimizerStates(),
		LogLevel	ll = DEFAULT
	)

Take a set of core::XYZR particles and relax them relative to a set of restraints. Excluded volume is handle separately, so don't include it in the passed list of restraints.

/**
 *  \file optimize_balls.cpp
 *  \brief A Score on the distance between a pair of particles.
 *
 *  Copyright 2007-2017 IMP Inventors. All rights reserved.
 */

#include <IMP/example/optimizing.h>
#include <IMP/container/generic.h>
#include <IMP/core/ConjugateGradients.h>
#include <IMP/core/MonteCarlo.h>
#include <IMP/core/SerialMover.h>
#include <IMP/core/BallMover.h>
#include <IMP/container/ClosePairContainer.h>
#include <IMP/core/rigid_bodies.h>
#include <IMP/core/SphereDistancePairScore.h>
#include <IMP/log_macros.h>
#include <IMP/container/ListSingletonContainer.h>
#include <boost/ptr_container/ptr_vector.hpp>
#include <IMP/scoped.h>
#include <IMP/PairPredicate.h>

/*
   \example optimize_balls.cpp
   This is a C++ equivalent to the optimize_balls.py python example.
*/

IMPEXAMPLE_BEGIN_NAMESPACE

core::MonteCarloMover *create_serial_mover(Model *m,
                               const ParticleIndexes &pis) {
  core::MonteCarloMovers movers;
  for (unsigned int i = 0; i < pis.size(); ++i) {
    double scale = core::XYZR(m, pis[i]).get_radius();
    movers.push_back(
        new core::BallMover(m, pis[i], scale * 2));
  }
  IMP_NEW(core::SerialMover, sm, (get_as<core::MonteCarloMoversTemp>(movers)));
  return sm.release();
}

/** Take a set of core::XYZR particles and relax them relative to a set of
    restraints. Excluded volume is handle separately, so don't include it
in the passed list of restraints. */
void optimize_balls(Model *m,
        const ParticleIndexes &pis,
                    const RestraintsTemp &rs,
                    const PairPredicates &excluded,
                    const OptimizerStates &opt_states, LogLevel ll) {
  // make sure that errors and log messages are marked as coming from this
  // function
  IMP_FUNCTION_LOG;
  SetLogState sls(ll);
  IMP_ALWAYS_CHECK(!pis.empty(), "No Particles passed.", ValueException);
  // double scale = core::XYZR(ps[0]).get_radius();

  IMP_NEW(core::SoftSpherePairScore, ssps, (10));
  IMP_NEW(core::ConjugateGradients, cg, (m));
  cg->set_optimizer_states(opt_states);
  {
    // set up restraints for cg
    IMP_NEW(container::ListSingletonContainer, lsc, (m, pis));
    IMP_NEW(container::ClosePairContainer, cpc,
            (lsc, 0, core::XYZR(m, pis[0]).get_radius()));
    cpc->add_pair_filters(excluded);
    Pointer<Restraint> r =
        container::create_restraint(ssps.get(), cpc.get());
    cg->set_scoring_function(rs + RestraintsTemp(1, r.get()));
    cg->set_optimizer_states(opt_states);
  }
  IMP_NEW(core::MonteCarlo, mc, (m));
  mc->set_optimizer_states(opt_states);
  IMP_NEW(core::IncrementalScoringFunction, isf, (m, pis, rs));
  {
    // set up MC
    mc->add_mover(create_serial_mover(m, pis));
    // we are special casing the nbl term for montecarlo, but using all for CG
    mc->set_incremental_scoring_function(isf);
    // use special incremental support for the non-bonded part
    isf->add_close_pair_score(ssps, 0, IMP::get_particles(m, pis), excluded);
    // make pointer vector
  }

  IMP_LOG_PROGRESS("Performing initial optimization" << std::endl);
  {
    boost::ptr_vector<ScopedSetFloatAttribute> attrs;
    for (unsigned int j = 0; j < attrs.size(); ++j) {
      attrs.push_back(
       new ScopedSetFloatAttribute(m->get_particle(pis[j]),
                             core::XYZR::get_radius_key(), 0));
    }
    cg->optimize(1000);
  }
  // shrink each of the particles, relax the configuration, repeat
  for (int i = 0; i < 11; ++i) {
    boost::ptr_vector<ScopedSetFloatAttribute> attrs;
    double factor = .1 * i;
    IMP_LOG_PROGRESS("Optimizing with radii at " << factor << " of full"
                                                 << std::endl);
    for (unsigned int j = 0; j < pis.size(); ++j) {
      attrs.push_back(
         new ScopedSetFloatAttribute(m->get_particle(pis[j]),
                      core::XYZR::get_radius_key(),
                                  core::XYZR(m, pis[j]).get_radius() * factor));
    }
    // changed all radii
    isf->set_moved_particles(isf->get_movable_indexes());
    for (int j = 0; j < 5; ++j) {
      mc->set_kt(100.0 / (3 * j + 1));
      mc->optimize(pis.size() * (j + 1) * 100);
      double e = cg->optimize(10);
      IMP_LOG_PROGRESS("Energy is " << e << std::endl);
      if (e < .000001) break;
    }
  }
}

IMPEXAMPLE_END_NAMESPACE

template<class ParticlesList , class BoundingVolume >

void IMP::example::randomize_particles	(	const ParticlesList &	ps,
		const BoundingVolume &	bv
	)

Randomize the positions of a set of particles within a bounding volume. Rigid bodies have their orientation randomized too.

Definition at line 32 of file randomizing.h.

Here is the call graph for this function: