On another note, we definitely need to reconcile the excluded volume/collision detection names one way or the other. It think excluded volume better fits the sense of the restraint since it is enforcing excluded volume not collisions (similar to connectivity restraint enforcing connectivity or fit enforcing that a fit to a map).
_______________________________________________On Oct 29, 2009, at 10:30 PM, Elina Tjioe wrote:Thx, Daniel. We'll keep that in mind. Also, I've added the wrapper for the FitRestraint.
ElinaOn Wed, Oct 28, 2009 at 1:54 PM, Daniel Russel <drussel@gmail.com> wrote:
If (as I hope), there will be more such functionality, I suggest it go into a separate module so it provides a single logical group and is separate from other helper functions which don't provide similar interfaces. Perhaps a "simple" module or something similar._______________________________________________
On Oct 28, 2009, at 1:25 PM, Notification of IMP commits wrote:
Author: etjioe@SALILAB.ORG
Date: 2009-10-28 13:25:46 -0700 (Wed, 28 Oct 2009)
New Revision: 3986
Added:
trunk/modules/helper/include/simplify_restraint.h
trunk/modules/helper/src/simplify_restraint.cpp
trunk/modules/helper/test/test_simple_connectivity_on_molecules.py
Modified:
trunk/modules/helper/SConscript
trunk/modules/helper/pyext/swig.i-in
Log:
Add helper functions for restraints
Modified: trunk/modules/helper/SConscript
===================================================================
--- trunk/modules/helper/SConscript 2009-10-28 18:25:03 UTC (rev 3985)
+++ trunk/modules/helper/SConscript 2009-10-28 20:25:46 UTC (rev 3986)
@@ -2,5 +2,5 @@
env.IMPModuleBuild(version="SVN",
- required_modules=['em', 'display','atom', 'core', 'algebra'],
+ required_modules=['em', 'display','atom', 'core', 'algebra', 'misc'],
optional_dependencies=['CGAL'])
Added: trunk/modules/helper/include/simplify_restraint.h
===================================================================
--- trunk/modules/helper/include/simplify_restraint.h (rev 0)
+++ trunk/modules/helper/include/simplify_restraint.h 2009-10-28 20:25:46 UTC (rev 3986)
@@ -0,0 +1,450 @@
+/**
+ * \file helper/simplify_restraint.h
+ * \brief Helper functions for restraints
+ *
+ * Copyright 2007-9 Sali Lab. All rights reserved.
+ */
+
+#ifndef IMPHELPER_SIMPLIFY_RESTRAINT_H
+#define IMPHELPER_SIMPLIFY_RESTRAINT_H
+
+#include "config.h"
+#include <IMP/SingletonContainer.h>
+#include <IMP/atom.h>
+#include <IMP/core.h>
+#include <IMP/misc.h>
+#include <IMP/em/FitRestraint.h>
+#include <IMP/em/DensityMap.h>
+#include <IMP/core/rigid_bodies.h>
+
+IMPHELPER_BEGIN_NAMESPACE
+
+
+//! Simple collision detection.
+/**
+ \note SimpleCollision stores pointers to PairsRestraint, HarmonicLowerBound,
+ and ClosePairsScoreState.
+ \note It provides convenient methods to change mean, k, standard deviation,
+ slack and distance.
+ \see PairsRestraint
+ */
+class IMPHELPEREXPORT SimpleCollision
+{
+public:
+ /** Creates collision detection on rigid bodies using
+ SphereDistancePairScore and ClosePairsScoreState.
+ The nonbonded list defined for the score state is refined using
+ RigidClosePairsFinder.
+
+ \see SphereDistancePairScore
+ \see HarmonicLowerBound
+ \see ClosePairsScoreState
+ \see ListSingletonContainer
+ \see RigidClosePairsFinder
+ */
+ friend SimpleCollision create_simple_collision_on_rigid_bodies(
+ core::RigidBodies *rbs);
+
+ core::PairsRestraint *restraint()
+ {
+ return pairs_restraint_;
+ }
+
+ core::HarmonicLowerBound *harmonic_lower_bound()
+ {
+ return harmonic_lower_bound_;
+ }
+
+ core::ClosePairsScoreState *close_pairs_score_state()
+ {
+ return close_pairs_score_state_;
+ }
+
+ //! Set the mean for the HarmonicLowerBound.
+ /** The default mean is 0.
+ */
+ void set_mean(Float mean)
+ {
+ harmonic_lower_bound_->set_mean(mean);
+ }
+
+ //! Set the standard deviation for the HarmonicLowerBound.
+ void set_stddev(Float sd)
+ {
+ static Float k = harmonic_lower_bound_->k_from_standard_deviation(sd);
+ harmonic_lower_bound_->set_k(k);
+ }
+
+ //! Set the spring constant for the HarmonicLowerBound.
+ /** The default k is 1.
+ */
+ void set_k(Float k)
+ {
+ harmonic_lower_bound_->set_k(k);
+ }
+
+ //! Set the amount of slack for the ClosePairsScoreState.
+ /** The default slack is 2.
+ */
+ void set_slack(Float slack)
+ {
+ close_pairs_score_state_->set_slack(slack);
+ }
+
+ //! Set the distance threshold for the ClosePairsScoreState.
+ /** Uses the default distance in the ClosePairsScoreState.
+ */
+ void set_distance(Float distance)
+ {
+ close_pairs_score_state_->set_distance(distance);
+ }
+
+ VersionInfo get_version_info() const
+ {
+ return IMP::get_module_version_info();
+ }
+
+ void show(std::ostream &out = std::cout) const
+ {
+ out << "SimpleCollision(";
+ if ( pairs_restraint_ )
+ pairs_restraint_->show(out);
+ out << ")";
+ }
+
+private:
+ // prevent unauthorized creation
+ SimpleCollision(core::PairsRestraint *pairs_restraint,
+ core::HarmonicLowerBound *harmonic_lower_bound,
+ core::ClosePairsScoreState *close_pairs_score_state)
+ : pairs_restraint_(pairs_restraint)
+ , harmonic_lower_bound_(harmonic_lower_bound)
+ , close_pairs_score_state_(close_pairs_score_state)
+ {}
+
+ IMP::Pointer<core::PairsRestraint> pairs_restraint_;
+ IMP::Pointer<core::HarmonicLowerBound> harmonic_lower_bound_;
+ IMP::Pointer<core::ClosePairsScoreState> close_pairs_score_state_;
+};
+
+//! Simple connectivity restraint.
+/**
+ \note SimpleConnectivity stores pointers to ConnectivityRestraint,
+ and HarmonicUpperBound.
+ \note It provides convenient methods to change mean, k,
+ and standard deviation.
+ \see ConnectivityRestraint
+ */
+class IMPHELPEREXPORT SimpleConnectivity
+{
+public:
+
+ /** Creates ConnectivityRestraint on rigid bodies using
+ RigidBodyDistancePairScore and RigidMembersRefiner.
+
+ \see RigidBodyDistancePairScore
+ \see SphereDistancePairScore
+ \see HarmonicUpperBound
+ \see core::RigidMembersRefiner
+ */
+ friend SimpleConnectivity create_simple_connectivity_on_rigid_bodies(
+ core::RigidBodies *rbs);
+
+ /** Creates ConnectivityRestraint on molecules using LowestRefinedPairScore
+ and LeavesRefiner.
+
+ \see LowestRefinedPairScore
+ \see SphereDistancePairScore
+ \see HarmonicUpperBound
+ \see LeavesRefiner
+ */
+ friend SimpleConnectivity create_simple_connectivity_on_molecules(
+ Particles *ps);
+
+ core::ConnectivityRestraint *restraint()
+ {
+ return connectivity_restraint_;
+ }
+
+ core::HarmonicUpperBound *harmonic_upper_bound()
+ {
+ return harmonic_upper_bound_;
+ }
+
+ //! Set the mean for the HarmonicUpperBound.
+ /** The default mean is 0.
+ */
+ void set_mean(Float mean)
+ {
+ harmonic_upper_bound_->set_mean(mean);
+ }
+
+ //! Set the standard deviation for the HarmonicUpperBound.
+ void set_stddev(Float sd)
+ {
+ static Float k = harmonic_upper_bound_->k_from_standard_deviation(sd);
+ harmonic_upper_bound_->set_k(k);
+ }
+
+ //! Set the spring constant for the HarmonicUpperBound.
+ /** The default k is 1.
+ */
+ void set_k(Float k)
+ {
+ harmonic_upper_bound_->set_k(k);
+ }
+
+ VersionInfo get_version_info() const
+ {
+ return IMP::get_module_version_info();
+ }
+
+ void show(std::ostream &out = std::cout) const
+ {
+ out << "SimpleConnectivity(";
+ if ( connectivity_restraint_ )
+ connectivity_restraint_->show(out);
+ out << ")";
+ }
+
+private:
+ // prevent unauthorized creation
+ SimpleConnectivity(
+ core::ConnectivityRestraint *connectivity_restraint,
+ core::HarmonicUpperBound *harmonic_upper_bound)
+ : connectivity_restraint_(connectivity_restraint)
+ , harmonic_upper_bound_(harmonic_upper_bound)
+ {}
+
+ IMP::Pointer<core::ConnectivityRestraint> connectivity_restraint_;
+ IMP::Pointer<core::HarmonicUpperBound> harmonic_upper_bound_;
+};
+
+//! Simple distance restraint between two particles.
+/**
+ \note SimpleDistance stores pointers to DistanceRestraint, and
+ HarmonicUpperBound.
+ \note It provides convenient methods to change mean, k, and
+ standard deviation.
+
+ \see DistanceRestraint
+ */
+class IMPHELPEREXPORT SimpleDistance
+{
+public:
+
+ /** Creates DistanceRestraint using HarmonicUpperBound scoring function
+ as default.
+ \param[in] ps Pointer to two particles in distance restraint.
+ */
+ friend SimpleDistance create_simple_distance(Particles *ps);
+
+ core::DistanceRestraint *restraint()
+ {
+ return distance_restraint_;
+ }
+
+ core::HarmonicUpperBound *harmonic_upper_bound()
+ {
+ return harmonic_upper_bound_;
+ }
+
+ //! Set the mean for the HarmonicUpperBound.
+ /** The default mean is 0.
+ */
+ void set_mean(Float mean)
+ {
+ harmonic_upper_bound_->set_mean(mean);
+ }
+
+ //! Set the standard deviation for the HarmonicUpperBound.
+ void set_stddev(Float sd)
+ {
+ static Float k = harmonic_upper_bound_->k_from_standard_deviation(sd);
+ harmonic_upper_bound_->set_k(k);
+ }
+
+ //! Set the spring constant for the HarmonicUpperBound.
+ /** The default k is 1.
+ */
+ void set_k(Float k)
+ {
+ harmonic_upper_bound_->set_k(k);
+ }
+
+ VersionInfo get_version_info() const
+ {
+ return IMP::get_module_version_info();
+ }
+
+ void show(std::ostream &out = std::cout) const
+ {
+ out << "SimpleDistance(";
+ if ( distance_restraint_ )
+ distance_restraint_->show(out);
+ out << ")";
+ }
+
+private:
+ // prevent unauthorized creation
+ SimpleDistance(
+ core::DistanceRestraint *distance_restraint,
+ core::HarmonicUpperBound *harmonic_upper_bound)
+ : distance_restraint_(distance_restraint)
+ , harmonic_upper_bound_(harmonic_upper_bound)
+ {}
+
+ IMP::Pointer<core::DistanceRestraint> distance_restraint_;
+ IMP::Pointer<core::HarmonicUpperBound> harmonic_upper_bound_;
+};
+
+//! Simple diameter restraint.
+/**
+ \note SimpleDiameter stores pointers to DiameterRestraint, and
+ HarmonicUpperBound.
+ \note It provides convenient methods to change mean, k, and
+ standard deviation.
+ \see DiameterRestraint
+ */
+class IMPHELPEREXPORT SimpleDiameter
+{
+public:
+
+ /** Creates DiameterRestraint using HarmonicUpperBound scoring function
+ as default.
+ \param[in] ps Pointer to particles in diameter restraint.
+ \param[in] diameter Diameter.
+ \see ListSingletonContainer
+ */
+ friend SimpleDiameter create_simple_diameter(Particles *ps, Float diameter);
+
+ core::DiameterRestraint *restraint()
+ {
+ return diameter_restraint_;
+ }
+
+ core::HarmonicUpperBound *harmonic_upper_bound()
+ {
+ return harmonic_upper_bound_;
+ }
+
+ //! Set the mean for the HarmonicUpperBound.
+ /** The default mean is 0.
+ */
+ void set_mean(Float mean)
+ {
+ harmonic_upper_bound_->set_mean(mean);
+ }
+
+ //! Set the standard deviation for the HarmonicUpperBound.
+ void set_stddev(Float sd)
+ {
+ static Float k = harmonic_upper_bound_->k_from_standard_deviation(sd);
+ harmonic_upper_bound_->set_k(k);
+ }
+
+ //! Set the spring constant for the HarmonicUpperBound.
+ /** The default k is 1.
+ */
+ void set_k(Float k)
+ {
+ harmonic_upper_bound_->set_k(k);
+ }
+
+ VersionInfo get_version_info() const
+ {
+ return IMP::get_module_version_info();
+ }
+
+ void show(std::ostream &out = std::cout) const
+ {
+ out << "SimpleDiameter(";
+ if ( diameter_restraint_ )
+ diameter_restraint_->show(out);
+ out << ")";
+ }
+
+private:
+ // prevent unauthorized creation
+ SimpleDiameter(
+ core::DiameterRestraint *diameter_restraint,
+ core::HarmonicUpperBound *harmonic_upper_bound)
+ : diameter_restraint_(diameter_restraint)
+ , harmonic_upper_bound_(harmonic_upper_bound)
+ {}
+
+ IMP::Pointer<core::DiameterRestraint> diameter_restraint_;
+ IMP::Pointer<core::HarmonicUpperBound> harmonic_upper_bound_;
+};
+
+//! Simple excluded volume restraint.
+/**
+ \see ExcludedVolumeRestraint
+ */
+class IMPHELPEREXPORT SimpleExcludedVolume
+{
+public:
+
+ /** Creates ExcludedVolumeRestraint using LeavesRefiner.
+ \see ListSingletonContainer
+ */
+ friend SimpleExcludedVolume create_simple_excluded_volume_on_rigid_bodies(
+ core::RigidBodies *rbs);
+
+ core::ExcludedVolumeRestraint *restraint()
+ {
+ return excluded_volume_restraint_;
+ }
+
+ VersionInfo get_version_info() const
+ {
+ return IMP::get_module_version_info();
+ }
+
+ void show(std::ostream &out = std::cout) const
+ {
+ out << "SimpleExcludedVolume(";
+ if ( excluded_volume_restraint_ )
+ excluded_volume_restraint_->show(out);
+ out << ")";
+ }
+
+private:
+ // prevent unauthorized creation
+ SimpleExcludedVolume(
+ core::ExcludedVolumeRestraint *excluded_volume_restraint)
+ : excluded_volume_restraint_(excluded_volume_restraint)
+ {}
+
+ IMP::Pointer<core::ExcludedVolumeRestraint> excluded_volume_restraint_;
+};
+
+IMPHELPEREXPORT SimpleCollision create_simple_collision_on_rigid_bodies(
+ core::RigidBodies *rbs);
+
+IMPHELPEREXPORT SimpleConnectivity create_simple_connectivity_on_rigid_bodies(
+ core::RigidBodies *rbs);
+
+IMPHELPEREXPORT SimpleConnectivity create_simple_connectivity_on_molecules(
+ Particles *ps);
+
+IMPHELPEREXPORT SimpleDistance create_simple_distance(Particles *ps);
+
+IMPHELPEREXPORT SimpleDiameter create_simple_diameter(
+ Particles *ps, Float diameter);
+
+IMPHELPEREXPORT SimpleExcludedVolume
+ create_simple_excluded_volume_on_rigid_bodies(
+ core::RigidBodies *rbs);
+
+IMPHELPEREXPORT em::DensityMap *load_map(
+ char const *map_fn, double spacing, double resolution);
+
+IMPHELPEREXPORT em::FitRestraint *create_em_restraint(
+ atom::Hierarchies const &mhs, em::DensityMap *dmap);
+
+IMPHELPEREXPORT Particles set_rigid_bodies(atom::Hierarchies const &mhs);
+
+IMPHELPER_END_NAMESPACE
+
+#endif /* IMPHELPER_SIMPLIFY_RESTRAINT_H */
Modified: trunk/modules/helper/pyext/swig.i-in
===================================================================
--- trunk/modules/helper/pyext/swig.i-in 2009-10-28 18:25:03 UTC (rev 3985)
+++ trunk/modules/helper/pyext/swig.i-in 2009-10-28 20:25:46 UTC (rev 3986)
@@ -3,3 +3,4 @@
%include "IMP/helper/covers.h"
%include "IMP/helper/atom_hierarchy.h"
%include "IMP/helper/simplify_atom_hierarchy.h"
+%include "IMP/helper/simplify_restraint.h"
Added: trunk/modules/helper/src/simplify_restraint.cpp
===================================================================
--- trunk/modules/helper/src/simplify_restraint.cpp (rev 0)
+++ trunk/modules/helper/src/simplify_restraint.cpp 2009-10-28 20:25:46 UTC (rev 3986)
@@ -0,0 +1,263 @@
+/**
+ * \file simplify_restraint.cpp
+ * \brief Support for restraints.
+ *
+ * Copyright 2007-9 Sali Lab. All rights reserved.
+ *
+ */
+
+#include "IMP/helper/simplify_restraint.h"
+#include "IMP/helper/rigid_bodies.h"
+#include <IMP/em/DensityMap.h>
+#include <IMP/em/MRCReaderWriter.h>
+
+IMPHELPER_BEGIN_NAMESPACE
+
+SimpleCollision create_simple_collision_on_rigid_bodies(core::RigidBodies *rbs)
+{
+ IMP_USAGE_CHECK(rbs->size() > 0, "At least one particle should be given",
+ ValueException);
+
+ /****** Set up the nonbonded list ******/
+ // Tell nbl on which particles you work on
+ // Look for close pairs within the list
+
+ IMP_NEW(core::ListSingletonContainer, lsc, ());
+ lsc->add_particles(*rbs);
+ IMP_NEW(core::ClosePairsScoreState, nbl, (lsc));
+
+ /****** Refine the nonbonded list ******/
+ // Set up the list of close pairs of each pair in NBL
+ // because you want to restraint the actual rigid bodies and not its particles
+ // Look for close members of the rigid bodies, one from each rigid body
+
+ //if set_close_pairs_finder is not called, then use the non refined list
+ //if rcpf omitted, then the score is between 2 spheres
+ IMP_NEW(core::RigidClosePairsFinder, rcpf, ());
+ nbl->set_close_pairs_finder(rcpf);
+ // Set the amount particles need to move before the list is updated
+ nbl->set_slack(2);
+
+ /****** Define the score used on each pair in the refined list ******/
+ // Score the distance between the spheres of each particles
+ // Each particle is required to have x,y,z and a radius
+ // The distance is going to be penalized by a harmonic lower bound with
+ // mean = 0 and force constant (k) = 1 kcal/mol/A/A
+ // The mean and k can be changed later on by calling set_mean and set_k
+ // k can also be obtained given the Gaussian standard deviation (angstroms),
+ // which can be changed using set_stddev
+
+ IMP_NEW(core::HarmonicLowerBound, h, (0, 1)); // (mean, force constant k)
+ IMP_NEW(core::SphereDistancePairScore, sdps, (h));
+
+ /****** Set the restraint ******/
+ // Define the restraint, work on all pairs and score them with sdps
+ // Add the restraint to the model
+
+ IMP_NEW(core::PairsRestraint, evr, (sdps, nbl->get_close_pairs_container()));
+
+ /****** Add score state and restraint to the model ******/
+
+ Model *mdl = (*rbs)[0].get_model();
+ mdl->add_score_state(nbl);
+ mdl->add_restraint(evr);
+
+ /****** Return a SimpleCollision object ******/
+
+ return SimpleCollision(evr, h, nbl);
+}
+
+SimpleConnectivity create_simple_connectivity_on_rigid_bodies(
+ core::RigidBodies *rbs)
+{
+ IMP_USAGE_CHECK(rbs->size() > 0, "At least one particle should be given",
+ ValueException);
+
+ /****** Define Refiner ******/
+ // Use RigidMembersRefiner when you want the set of particles representing
+ // a rigid body to be the same as the set of members
+
+ IMP_NEW(core::RigidMembersRefiner, rmr, ());
+
+ /****** Define PairScore ******/
+ // Use RigidBodyDistancePairScore to accelerate computation of the distance
+ // between two rigid bodies. The distance is defined as the minimal distance
+ // over all bipartite pairs with one particle taken from each rigid body.
+
+ IMP_NEW(core::HarmonicUpperBound, h, (0, 1));
+ IMP_NEW(core::SphereDistancePairScore, sdps, (h));
+ IMP_NEW(core::RigidBodyDistancePairScore, rdps, (sdps, rmr));
+
+ /****** Set the restraint ******/
+
+ IMP_NEW(core::ConnectivityRestraint, cr, (rdps));
+ for ( size_t i=0; i<rbs->size(); ++i )
+ cr->set_particles((*rbs)[i].get_particle());
+
+ /****** Add restraint to the model ******/
+
+ Model *mdl = (*rbs)[0].get_model();
+ mdl->add_restraint(cr);
+
+ /****** Return a SimpleConnectivity object ******/
+
+ return SimpleConnectivity(cr, h);
+}
+
+SimpleConnectivity create_simple_connectivity_on_molecules(Particles *ps)
+{
+ IMP_USAGE_CHECK(ps->size() > 0, "At least one particle should be given",
+ ValueException);
+
+
+ /****** Define Refiner ******/
+ // Use LeavesRefiner for the hierarchy leaves under a particle
+
+ IMP_NEW(core::LeavesRefiner, lr, (atom::Hierarchy::get_traits()));
+
+ /****** Define PairScore ******/
+ // Score on the lowest of the pairs defined by refining the two particles.
+
+ IMP_NEW(core::HarmonicUpperBound, h, (0, 1));
+ IMP_NEW(core::SphereDistancePairScore, sdps, (h));
+ IMP_NEW(misc::LowestRefinedPairScore, lrps, (lr, sdps));
+
+ /****** Set the restraint ******/
+
+ IMP_NEW(core::ConnectivityRestraint, cr, (lrps));
+ cr->set_particles((*ps));
+
+ /****** Add restraint to the model ******/
+
+ Model *mdl = (*ps)[0]->get_model();
+ mdl->add_restraint(cr);
+
+ /****** Return a SimpleConnectivity object ******/
+
+ return SimpleConnectivity(cr, h);
+}
+
+SimpleDistance create_simple_distance(Particles *ps)
+{
+ IMP_USAGE_CHECK(ps->size() == 2, "Two particles should be given",
+ ValueException);
+
+ /****** Set the restraint ******/
+
+ IMP_NEW(core::HarmonicUpperBound, h, (0, 1));
+ IMP_NEW(core::DistanceRestraint, dr, (h, (*ps)[0], (*ps)[1]));
+
+ /****** Add restraint to the model ******/
+
+ Model *mdl = (*ps)[0]->get_model();
+ mdl->add_restraint(dr);
+
+ /****** Return a SimpleDistance object ******/
+
+ return SimpleDistance(dr, h);
+}
+
+SimpleDiameter create_simple_diameter(Particles *ps, Float diameter)
+{
+ IMP_USAGE_CHECK(ps->size() >= 2, "At least two particles should be given",
+ ValueException);
+
+ /****** Set the restraint ******/
+
+ IMP_NEW(core::HarmonicUpperBound, h, (0, 1));
+ IMP_NEW(core::ListSingletonContainer, lsc, ());
+ lsc->add_particles(*ps);
+ IMP_NEW(core::DiameterRestraint, dr, (h, lsc, diameter));
+
+ /****** Add restraint to the model ******/
+
+ Model *mdl = (*ps)[0]->get_model();
+ mdl->add_restraint(dr);
+
+ /****** Return a SimpleDiameter object ******/
+
+ return SimpleDiameter(dr, h);
+}
+
+SimpleExcludedVolume create_simple_excluded_volume_on_rigid_bodies(
+ core::RigidBodies *rbs)
+{
+ IMP_USAGE_CHECK(rbs->size() > 0, "At least one particle should be given",
+ ValueException);
+
+ /****** Set the restraint ******/
+
+ IMP_NEW(core::ListSingletonContainer, lsc, ());
+ lsc->add_particles(*rbs);
+
+ IMP_NEW(core::LeavesRefiner, lr, (atom::Hierarchy::get_traits()));
+ IMP_NEW(core::ExcludedVolumeRestraint, evr, (lsc, lr));
+
+ /****** Add restraint to the model ******/
+
+ Model *mdl = (*rbs)[0].get_model();
+ mdl->add_restraint(evr);
+
+ /****** Return a SimpleExcludedVolume object ******/
+
+ return SimpleExcludedVolume(evr);
+}
+
+Particles set_rigid_bodies(atom::Hierarchies const &mhs)
+{
+ size_t mhs_size = mhs.size();
+
+ IMP_USAGE_CHECK(mhs_size > 0, "At least one hierarchy should be given",
+ ValueException);
+
+ Particles rbs;
+ Model *mdl = mhs[0].get_model();
+
+ for ( size_t i=0; i<mhs_size; ++i )
+ {
+ // The rigid body is set to be optimized
+ ScoreState *rb_state = create_rigid_body(mhs[i]);
+
+ // Add the score state to the model to make the body rigid
+ // Remove the score state from the model to stop keeping the body rigid
+ mdl->add_score_state(rb_state);
+
+ rbs.push_back(mhs[i].get_particle());
+ }
+ return rbs;
+}
+
+em::DensityMap *load_map(char const *map_fn, double spacing, double resolution)
+{
+ em::MRCReaderWriter mrw;
+ em::DensityMap *dmap = em::read_map(map_fn, mrw);
+ em::DensityHeader *dmap_header = dmap->get_header_writable();
+ dmap_header->set_spacing(spacing);
+ dmap_header->set_resolution(resolution);
+
+ return dmap;
+}
+
+em::FitRestraint *create_em_restraint(
+ atom::Hierarchies const &mhs, em::DensityMap *dmap)
+{
+ size_t mhs_size = mhs.size();
+
+ IMP_USAGE_CHECK(mhs_size > 0, "At least one hierarchy should be given",
+ runtime_error);
+
+ Particles ps;
+ for ( size_t i=0; i<mhs_size; ++i )
+ {
+ Particles pss = core::get_leaves(mhs[i]);
+ for ( size_t j=0; j<pss.size(); ++j )
+ ps.push_back(pss[j]);
+ }
+ IMP_NEW(em::FitRestraint, fit_rs, (ps, dmap,
+ core::XYZR::get_default_radius_key(),
+ atom::Mass::get_mass_key(), 1.0));
+ fit_rs->set_model(mhs[0].get_particle()->get_model());
+ return fit_rs;
+}
+
+IMPHELPER_END_NAMESPACE
Added: trunk/modules/helper/test/test_simple_connectivity_on_molecules.py
===================================================================
--- trunk/modules/helper/test/test_simple_connectivity_on_molecules.py (rev 0)
+++ trunk/modules/helper/test/test_simple_connectivity_on_molecules.py 2009-10-28 20:25:46 UTC (rev 3986)
@@ -0,0 +1,77 @@
+import unittest
+import os
+import IMP
+import IMP.test
+import IMP.atom
+import IMP.helper
+
+class SimpleConnectivityTests(IMP.test.TestCase):
+ """Tests for the SimpleConnectivity """
+
+ def test_connectivity(self):
+
+ def create_particles(m, coordinates):
+ ps = IMP.Particles()
+ radkey = IMP.FloatKey("radius")
+ for pt in coordinates:
+ p = self.create_point_particle(m, *pt)
+ p.add_attribute(radkey, 1.0, False)
+ ps.append(p)
+ return ps
+
+ def compute_and_print_distances(ps):
+ distances = list()
+ for i, p0 in enumerate(ps):
+ print "*****************Distance %d******************" % i
+ for p1 in ps:
+ if p1 == p0:
+ continue
+ dist = self.particle_distance(p0, p1)
+ print dist
+ distances.append(dist)
+ print "*******************************************"
+ return distances
+
+ def check_closer_distances(old, new):
+ for od, nd in zip(old, new):
+ self.assert_(od > nd)
+
+ IMP.set_log_level(IMP.VERBOSE)
+
+ m = IMP.Model()
+ ps = create_particles(m, [(0.0, 0.0, 0.0), (100.0, 0.0, 0.0), (0.0, 100.0, 0.0),
+ (0.0, 0.0, 100.0)])
+
+ old_dist = compute_and_print_distances(ps)
+
+ sc = IMP.helper.create_simple_connectivity_on_molecules(ps)
+
+ h = sc.harmonic_upper_bound()
+ r = sc.restraint()
+
+ sc.set_mean(0)
+ self.assertEquals(h.get_mean(), 0)
+
+ sc.set_k(1.5)
+ self.assertInTolerance(h.get_k(), 1.5, 1e-4)
+
+ sc.set_stddev(3.5)
+ self.assertInTolerance(h.get_k(), h.k_from_standard_deviation(3.5), 1e-4)
+
+ o = IMP.core.ConjugateGradients()
+ o.set_threshold(1e-4)
+ o.set_model(m)
+ o.optimize(1000)
+
+ new_dist = compute_and_print_distances(ps)
+
+ check_closer_distances(old_dist, new_dist)
+
+ r.show()
+ m.evaluate(False)
+
+ pps = r.get_connected_pairs()
+
+
+if __name__ == '__main__':
+ unittest.main()
_______________________________________________
IMP-commits mailing list
IMP-commits@salilab.org
https://salilab.org/mailman/listinfo/imp-commits
IMP-dev mailing list
IMP-dev@salilab.org
https://salilab.org/mailman/listinfo/imp-dev
_______________________________________________
IMP-dev mailing list
IMP-dev@salilab.org
https://salilab.org/mailman/listinfo/imp-dev
IMP-dev mailing list
IMP-dev@salilab.org
https://salilab.org/mailman/listinfo/imp-dev