Another advantage is that you could shorten all the names by removing the "Simple" prefix (since everything in the module would be that).
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. > > Elina > > On 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::Pointercore::PairsRestraint pairs_restraint_; > + IMP::Pointercore::HarmonicLowerBound harmonic_lower_bound_; > + IMP::Pointercore::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::Pointercore::ConnectivityRestraint connectivity_restraint_; > + IMP::Pointercore::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::Pointercore::DistanceRestraint distance_restraint_; > + IMP::Pointercore::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::Pointercore::DiameterRestraint diameter_restraint_; > + IMP::Pointercore::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::Pointercore::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