Re: [IMP-dev] [IMP-commits] r3986 - in trunk/modules/helper: . include pyext src test

[Daniel Russel <drussel@gmail.com>]

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