Detailed Description

Restrain the diameter of a set of points.

This restraint shows how to write a restraint that includes a ScoreState which is needed to compute some invariant.

Note: Be sure to check out the swig wrapper file and how it wraps this class.

The source code is as follows:

/**
 *  \file IMP/example/ExampleComplexRestraint.h
 *  \brief A restraint to maintain the diameter of a set of points
 *
 *  Copyright 2007-2022 IMP Inventors. All rights reserved.
 */
#ifndef IMPEXAMPLE_EXAMPLE_COMPLEX_RESTRAINT_H
#define IMPEXAMPLE_EXAMPLE_COMPLEX_RESTRAINT_H
#include <IMP/example/example_config.h>
#include <IMP/PairContainer.h>
#include <IMP/SingletonContainer.h>
#include <IMP/Restraint.h>
#include <IMP/ScoreState.h>
#include <IMP/UnaryFunction.h>
IMPEXAMPLE_BEGIN_NAMESPACE
//! Restrain the diameter of a set of points
/** This restraint shows how to write a restraint that includes
    a ScoreState which is needed to compute some invariant.
    \note Be sure to check out the swig wrapper file and how it
    wraps this class.
    The source code is as follows:
    \include ExampleComplexRestraint.h
    \include ExampleComplexRestraint.cpp
*/
class IMPEXAMPLEEXPORT ExampleComplexRestraint : public Restraint {
  Pointer<ScoreState> ss_;
  ParticleIndex p_;
  Float diameter_;
  Pointer<SingletonContainer> sc_;
  Pointer<UnaryFunction> f_;
  FloatKey dr_;
 public:
  //! Use f to restrain particles in sc to be within diameter of one another
  /** f should have a minimum at 0 and be an upper bound-style function.
   */
  ExampleComplexRestraint(UnaryFunction *f, SingletonContainer *sc,
                          Float diameter,
                          std::string name = "ExampleComplexRestraint%1%");
  virtual double unprotected_evaluate(IMP::DerivativeAccumulator *accum)
      const override;
  virtual IMP::ModelObjectsTemp do_get_inputs() const override;
  IMP_OBJECT_METHODS(ExampleComplexRestraint);
};
IMPEXAMPLE_END_NAMESPACE
#endif /* IMPEXAMPLE_EXAMPLE_COMPLEX_RESTRAINT_H */

/**
 *  \file example/ExampleComplexRestraint.cpp
 *  \brief Restrain the diameter of a set of points.
 *
 *  Copyright 2007-2022 IMP Inventors. All rights reserved.
 *
 */
#include "IMP/example/ExampleComplexRestraint.h"
#include <IMP/PairContainer.h>
#include <IMP/particle_index.h>
#include <IMP/core/XYZR.h>
#include <IMP/core/FixedRefiner.h>
#include <IMP/core/CoverRefined.h>
#include <IMP/core/SingletonConstraint.h>
#include <IMP/core/DistancePairScore.h>
#include <IMP/core/internal/evaluate_distance_pair_score.h>
#include <boost/lambda/lambda.hpp>
IMPEXAMPLE_BEGIN_NAMESPACE
ExampleComplexRestraint::ExampleComplexRestraint(UnaryFunction *f,
                                                 SingletonContainer *sc,
                                                 Float diameter,
                                                 std::string name)
    : Restraint(sc->get_model(), name),
      diameter_(diameter),
      sc_(sc),
      f_(f) {
  IMP_USAGE_CHECK(sc->get_indexes().size() > 2,
                  "Need at least two particles to restrain diameter");
  IMP_USAGE_CHECK(diameter > 0, "The diameter must be positive");
  f_->set_was_used(true);
  sc_->set_was_used(true);
  p_ = get_model()->add_particle(get_name() + " particle");
  core::XYZR d = core::XYZR::setup_particle(get_model(), p_);
  d.set_coordinates_are_optimized(false);
  Pointer<core::CoverRefined> cr =
      new core::CoverRefined(new core::FixedRefiner(IMP::get_particles(
                                 get_model(), sc_->get_indexes())),
                             0);
  ss_ = new core::SingletonConstraint(cr, nullptr, get_model(), p_);
}
double ExampleComplexRestraint::unprotected_evaluate(DerivativeAccumulator *da)
    const {
  IMP_CHECK_OBJECT(sc_.get());
  double v = 0;
  core::XYZ dp(get_model(), p_);
  double radius = diameter_ / 2.0;
  IMP_CONTAINER_FOREACH(SingletonContainer, sc_,
                        v += core::internal::evaluate_distance_pair_score(
                            dp, core::XYZ(get_model(), _1), da, f_.get(),
                            boost::lambda::_1 - radius););
  return v;
}
ModelObjectsTemp ExampleComplexRestraint::do_get_inputs() const {
  ModelObjectsTemp ret(
      IMP::get_particles(get_model(), sc_->get_all_possible_indexes()));
  ret.push_back(get_model()->get_particle(p_));
  ret.push_back(sc_);
  return ret;
}
IMPEXAMPLE_END_NAMESPACE

Definition at line 33 of file ExampleComplexRestraint.h.

Public Member Functions
	ExampleComplexRestraint (UnaryFunction f, SingletonContainer sc, Float diameter, std::string name="ExampleComplexRestraint%1%")
	Use f to restrain particles in sc to be within diameter of one another. More...

virtual IMP::ModelObjectsTemp	do_get_inputs () const override

virtual std::string	get_type_name () const override

virtual ::IMP::VersionInfo	get_version_info () const override
	Get information about the module and version of the object. More...

virtual double	unprotected_evaluate (IMP::DerivativeAccumulator *accum) const override
	Return the unweighted score for the restraint. More...

Public Member Functions inherited from IMP::Restraint
	Restraint (Model *m, std::string name)

Restraint *	create_current_decomposition () const
	Decompose this restraint into constituent terms for the current conf. More...

Restraint *	create_decomposition () const
	Decompose this restraint into constituent terms. More...

virtual ScoringFunction *	create_scoring_function (double weight=1.0, double max=NO_MAX) const
	Create a scoring function with only this restraint. More...

virtual RestraintInfo *	get_dynamic_info () const

virtual double	get_last_last_score () const
	Get the unweighted score from the last-but-one time it was evaluated. More...

virtual double	get_last_score () const

double	get_score () const

virtual RestraintInfo *	get_static_info () const

bool	get_was_good () const

virtual double	unprotected_evaluate_moved (DerivativeAccumulator *da, const ParticleIndexes &moved_pis, const ParticleIndexes &reset_pis) const
	Return the unweighted score, taking moving particles into account. More...

virtual double	unprotected_evaluate_if_good (DerivativeAccumulator *da, double max) const

virtual double	unprotected_evaluate_if_below (DerivativeAccumulator *da, double max) const
	The function calling this will treat any score >= max as bad. More...

virtual double	unprotected_evaluate_moved_if_below (DerivativeAccumulator *da, const ParticleIndexes &moved_pis, const ParticleIndexes &reset_pis, double max) const

virtual double	unprotected_evaluate_moved_if_good (DerivativeAccumulator *da, const ParticleIndexes &moved_pis, const ParticleIndexes &reset_pis, double max) const

void	set_weight (Float weight)

Float	get_weight () const

double	get_maximum_score () const

void	set_maximum_score (double s)

Public Member Functions inherited from IMP::ModelObject
	ModelObject (Model *m, std::string name)

bool	get_has_dependencies () const
	Return whether this object has dependencies computed. More...

bool	get_has_required_score_states () const
	Return whether score states are computed. More...

ModelObjectsTemp	get_inputs () const

ModelObjectsTemps	get_interactions () const
	Get the interacting sets induced by this ModelObject. More...

Model *	get_model () const

ModelObjectsTemp	get_outputs () const

const ScoreStatesTemp &	get_required_score_states () const
	Get the score states that are ancestors of this in the dependency graph. More...

void	set_has_dependencies (bool tf)
	Either invalidate the dependencies or ensure they are correct. More...

void	set_has_required_score_states (bool tf)
	Compute the required score states. More...

Public Member Functions inherited from IMP::Object
virtual void	clear_caches ()

CheckLevel	get_check_level () const

LogLevel	get_log_level () const

void	set_check_level (CheckLevel l)

void	set_log_level (LogLevel l)
	Set the logging level used in this object. More...

void	set_was_used (bool tf) const

void	show (std::ostream &out=std::cout) const

const std::string &	get_name () const

void	set_name (std::string name)

Additional Inherited Members
Protected Member Functions inherited from IMP::Restraint
virtual void	do_add_score_and_derivatives (ScoreAccumulator sa) const

virtual void	do_add_score_and_derivatives_moved (ScoreAccumulator sa, const ParticleIndexes &moved_pis, const ParticleIndexes &reset_pis) const

virtual Restraints	do_create_current_decomposition () const

virtual Restraints	do_create_decomposition () const

ModelObjectsTemp	do_get_outputs () const override

Protected Member Functions inherited from IMP::ModelObject
virtual ModelObjectsTemps	do_get_interactions () const

virtual void	handle_set_has_required_score_states (bool)

Protected Member Functions inherited from IMP::Object
	Object (std::string name)
	Construct an object with the given name. More...

virtual void	do_destroy ()

Constructor & Destructor Documentation

IMP::example::ExampleComplexRestraint::ExampleComplexRestraint	(	UnaryFunction *	f,
		SingletonContainer *	sc,
		Float	diameter,
		std::string	name = `"ExampleComplexRestraint%1%"`
	)

Use f to restrain particles in sc to be within diameter of one another.

f should have a minimum at 0 and be an upper bound-style function.

Member Function Documentation

virtual IMP::ModelObjectsTemp IMP::example::ExampleComplexRestraint::do_get_inputs ( ) const

overridevirtual

Get any Particle, Container or other ModelObjects read by this during evaluation. If you read everything in a container, you can just return that container.

Implements IMP::ModelObject.

virtual ::IMP::VersionInfo IMP::example::ExampleComplexRestraint::get_version_info ( ) const

overridevirtual

Get information about the module and version of the object.

Reimplemented from IMP::Object.

Definition at line 52 of file ExampleComplexRestraint.h.

virtual double IMP::example::ExampleComplexRestraint::unprotected_evaluate ( IMP::DerivativeAccumulator * da ) const

overridevirtual

Return the unweighted score for the restraint.

Reimplemented from IMP::Restraint.

The documentation for this class was generated from the following file:

ExampleComplexRestraint.h

Detailed Description

Public Member Functions

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation