IMP::example::ExampleComplexRestraint Class Reference

---

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 example/ExampleComplexRestraint.h
 *  \brief A restraint to maintain the diameter of a set of points
 *
 *  Copyright 2007-2012 IMP Inventors. All rights reserved.
 */

#ifndef IMPEXAMPLE_EXAMPLE_COMPLEX_RESTRAINT_H
#define IMPEXAMPLE_EXAMPLE_COMPLEX_RESTRAINT_H

#include "example_config.h"

#include <IMP/PairContainer.h>
#include <IMP/SingletonContainer.h>
#include <IMP/Restraint.h>
#include <IMP/restraint_macros.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_;
  Pointer<Particle> p_;
  Float diameter_;
  Pointer<SingletonContainer> sc_;
  Pointer<UnaryFunction> f_;
  FloatKey dr_;
public:
  //! Use f to restraint sc to be withing 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);

  IMP_RESTRAINT(ExampleComplexRestraint);

  void set_model(Model *m);
};


IMPEXAMPLE_END_NAMESPACE

#endif  /* IMPEXAMPLE_EXAMPLE_COMPLEX_RESTRAINT_H */

/**
 *  \file example/ExampleComplexRestraint.cpp
 *  \brief Restrain the diameter of a set of points.
 *
 *  Copyright 2007-2012 IMP Inventors. All rights reserved.
 *
 */

#include "IMP/example/ExampleComplexRestraint.h"
#include <IMP/PairContainer.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):
  Restraint(sc->get_model(), "ExampleComplexRestraint%1%"),
  diameter_(diameter),
  sc_(sc), f_(f){
  IMP_USAGE_CHECK(sc->get_number_of_particles()>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);
}

void ExampleComplexRestraint::set_model(Model *m) {
  if (m) {
    IMP_LOG(TERSE, "Creating components of ExampleComplexRestraint"
            << std::endl);
    Model *m= sc_->get_particle(0)->get_model();

    p_= new Particle(m);
    core::XYZR d= core::XYZR::setup_particle(p_);
    d.set_coordinates_are_optimized(false);
    Pointer<core::CoverRefined> cr
      = new core::CoverRefined(
              new core::FixedRefiner(sc_->get_particles()),
             0);
    ss_= new core::SingletonConstraint(cr, nullptr, p_);
    m->add_score_state(ss_);
  } else {
    IMP_LOG(TERSE, "Removing components of ExampleComplexRestraint"
            << std::endl);
    if (ss_) {
      IMP_CHECK_OBJECT(ss_.get());
      IMP_CHECK_OBJECT(p_.get());
      get_model()->remove_score_state(ss_);
      get_model()->remove_particle(p_);
      ss_=nullptr;
      p_=nullptr;
    }
  }
  Restraint::set_model(m);
}

double
ExampleComplexRestraint::unprotected_evaluate(DerivativeAccumulator *da) const {
  IMP_CHECK_OBJECT(sc_.get());
  double v=0;
  core::XYZ dp(p_);
  double radius= diameter_/2.0;
  IMP_FOREACH_SINGLETON(sc_,
    v+= core::internal::evaluate_distance_pair_score(dp,
                                               core::XYZ(_1),
                                               da, f_.get(),
                                               boost::lambda::_1-radius);
                        );
  return v;
}

void ExampleComplexRestraint::do_show(std::ostream &out) const {
  out << "diameter " << diameter_ << std::endl;
}

ParticlesTemp ExampleComplexRestraint::get_input_particles() const {
  ParticlesTemp ret(sc_->get_particles());
  ret.push_back(p_);
  return ret;
}

ContainersTemp ExampleComplexRestraint::get_input_containers() const {
  return ContainersTemp(1, sc_);
}

IMPEXAMPLE_END_NAMESPACE

Inheritance diagram for IMP::example::ExampleComplexRestraint:

List of all members.

Public Member Functions
	ExampleComplexRestraint (UnaryFunction *f, SingletonContainer *sc, Float diameter)
	Use f to restraint sc to be withing diameter of one another.
void	set_model (Model *m)
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.
Restraint *	create_decomposition () const
	Decompose this restraint into constituent terms.
double	evaluate (bool calc_derivs) const
	Return the score for this restraint for the current state of the model.
double	evaluate_if_below (bool calc_derivatives, double max) const
	See Model::evaluate_with_maximum()
double	evaluate_if_good (bool calc_derivatives) const
	See Model::evaluate_if_good()
double	get_last_score () const
bool	get_was_good () const
virtual double	unprotected_evaluate (DerivativeAccumulator *) const =0
virtual double	unprotected_evaluate_if_good (DerivativeAccumulator *da, double max) const
virtual double	unprotected_evaluate_if_below (DerivativeAccumulator *da, double max) const
virtual ContainersTemp	get_input_containers () const =0
virtual ParticlesTemp	get_input_particles () const =0
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)
ModelObjectsTemp	get_inputs () const
Model *	get_model () const
ModelObjectsTemp	get_outputs () const
Public Member Functions inherited from IMP::base::Object
std::size_t	__hash__ () const
virtual std::string	get_type_name () const =0
	Return a string identifying the type of the object.
virtual IMP::base::VersionInfo	get_version_info () const =0
	Get information about the module and version of the object.
void	set_check_level (CheckLevel l)
void	set_log_level (LogLevel l)
	Set the logging level used in this object.
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)

Static Public Member Functions
static ExampleComplexRestraint *	get_from (IMP::base::Object *o)

Additional Inherited Members
Protected Member Functions inherited from IMP::Restraint
virtual Restraints	do_create_current_decomposition () const
virtual Restraints	do_create_decomposition () const
Protected Member Functions inherited from IMP::ModelObject
virtual ModelObjectsTemp	do_get_inputs () const =0
virtual ModelObjectsTemp	do_get_outputs () const =0
virtual void	do_update_dependencies (const DependencyGraph &, const DependencyGraphVertexIndex &)
void	update_dependencies (const DependencyGraph &dg, const DependencyGraphVertexIndex &index)
Protected Member Functions inherited from IMP::base::Object
	Object (std::string name)

---

Constructor & Destructor Documentation

IMP::example::ExampleComplexRestraint::ExampleComplexRestraint	(	UnaryFunction *	f,
		SingletonContainer *	sc,
		Float	diameter
	)

Use f to restraint sc to be withing diameter of one another.

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

---

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

• ExampleComplexRestraint.h