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::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