constraints

Bindings for core::scoring::constraints namespace

class pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint

Bases: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint

Nested constraint where only the one with lowest energy is considered.

active_constraint(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AmbiguousConstraint::active_constraint() const –> class std::shared_ptr<const class core::scoring::constraints::Constraint>

add_individual_constraint(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, cst_in: pyrosetta.rosetta.core.scoring.constraints.Constraint) None

add individual constraint into MultiConstraint

C++: core::scoring::constraints::MultiConstraint::add_individual_constraint(class std::shared_ptr<const class core::scoring::constraints::Constraint>) –> void

atom(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, n: int) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::MultiConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

calculate_total_cst_score(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) float

C++: core::scoring::constraints::AmbiguousConstraint::calculate_total_cst_score(const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> double

choose_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, : pyrosetta.rosetta.numeric.random.RandomGenerator) int

C++: core::scoring::constraints::MultiConstraint::choose_effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &, class numeric::random::RandomGenerator &) –> unsigned long

clone(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AmbiguousConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)

Overloaded function.

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float

  2. dist(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : core::scoring::func::XYZ_Func) -> float

MultiConstraints don’t have a single distance

C++: core::scoring::constraints::MultiConstraint::dist(const class core::scoring::func::XYZ_Func &) const –> double

effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) int

C++: core::scoring::constraints::MultiConstraint::effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &) const –> unsigned long

empty_clone(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint) pyrosetta.rosetta.core.scoring.constraints.MultiConstraint

C++: core::scoring::constraints::AmbiguousConstraint::empty_clone() const –> class std::shared_ptr<class core::scoring::constraints::MultiConstraint>

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint, atom: pyrosetta.rosetta.core.id.AtomID, xyz: core::scoring::func::XYZ_Func, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t, weights: pyrosetta.rosetta.core.scoring.EMapVector) None

compute atom deriv

C++: core::scoring::constraints::AmbiguousConstraint::fill_f1_f2(const class core::id::AtomID &, const class core::scoring::func::XYZ_Func &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const class core::scoring::EMapVector &) const –> void

get_func(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) core::scoring::func::Func

Returns the func::Func object associated with this Constraint object.

C++: core::scoring::constraints::Constraint::get_func() const –> const class core::scoring::func::Func &

init_cst_score_types(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint) None

C++: core::scoring::constraints::AmbiguousConstraint::init_cst_score_types() –> void

member_constraints(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint) pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t

C++: core::scoring::constraints::MultiConstraint::member_constraints() const –> const class utility::vector1<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > > &

natoms(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint) int

number of atoms involved in this MultiConstraint container

C++: core::scoring::constraints::MultiConstraint::natoms() const –> unsigned long

read_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose) None
This method is totally redundant with read_def YAY

DON’T USE THIS ONE.. Most Constraint classes have not overloaded this one, but read_def ! OL

C++: core::scoring::constraints::Constraint::read_constraint(std::istream &, const class core::pose::Pose &) –> void

read_data(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream) None
initialize this Constraint from the given std::istream. It’s amazing

that there are three functions for doing this inside of Constraint.hh. SO WHAT IS THIS SUPPOSED TO DO ? not overloaded by e.g., AtomPairConstraint or CoordinateConstraint,

C++: core::scoring::constraints::Constraint::read_data(std::istream &) –> void

read_def(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint, data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: core::scoring::func::FuncFactory) None

read in constraint defiinition

C++: core::scoring::constraints::AmbiguousConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AmbiguousConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)

Overloaded function.

  1. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

  2. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, map: pyrosetta.rosetta.core.id.SequenceMapping) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::MultiConstraint::remapped_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

residues(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint) pyrosetta.rosetta.utility.vector1_unsigned_long

C++: core::scoring::constraints::MultiConstraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) bool

C++: core::scoring::constraints::AmbiguousConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint, xyz_func: core::scoring::func::XYZ_Func, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) None

compute score

C++: core::scoring::constraints::AmbiguousConstraint::score(const class core::scoring::func::XYZ_Func &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

score_type(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.core.scoring.ScoreType

Returns the ScoreType that this Constraint object will use.

C++: core::scoring::constraints::Constraint::score_type() const –> const enum core::scoring::ScoreType &

set_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, setting: int) None

C++: core::scoring::constraints::MultiConstraint::set_effective_sequence_separation(unsigned long) –> void

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_derivatives(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::MultiConstraint::setup_for_scoring(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::AmbiguousConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::constraints::MultiConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int, threshold: float) -> int

C++: core::scoring::constraints::AmbiguousConstraint::show_violations(std::ostream &, const class core::pose::Pose &, unsigned long, double) const –> unsigned long

size(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint) int

number of constraints that are held by this %MultiConstraint

C++: core::scoring::constraints::MultiConstraint::size() const –> unsigned long

steal_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose) None

take coordinates, distances, angles, etc from given pose

C++: core::scoring::constraints::Constraint::steal_def(const class core::pose::Pose &) –> void

to_string(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) str
Convenience function, returns the results of show() as a string.

Not to be overriden by derived classes.

C++: core::scoring::constraints::Constraint::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint) str

C++: core::scoring::constraints::AmbiguousConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraintCreator

Bases: pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator

Constraint creator for the AmbiguousConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraintCreator

C++: core::scoring::constraints::AmbiguousConstraintCreator::operator=(const class core::scoring::constraints::AmbiguousConstraintCreator &) –> class core::scoring::constraints::AmbiguousConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AmbiguousConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraintCreator) str

C++: core::scoring::constraints::AmbiguousConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint

Bases: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint

add_individual_constraint(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, cst_in: pyrosetta.rosetta.core.scoring.constraints.Constraint) None

add individual constraint into AmbiguousNMRConstraint

C++: core::scoring::constraints::AmbiguousNMRConstraint::add_individual_constraint(class std::shared_ptr<const class core::scoring::constraints::Constraint>) –> void

atom(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, n: int) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::MultiConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

choose_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, : pyrosetta.rosetta.numeric.random.RandomGenerator) int

C++: core::scoring::constraints::MultiConstraint::choose_effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &, class numeric::random::RandomGenerator &) –> unsigned long

clone(*args, **kwargs)

Overloaded function.

  1. clone(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AmbiguousNMRConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

  1. clone(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, func: core::scoring::func::Func) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AmbiguousNMRConstraint::clone(class std::shared_ptr<class core::scoring::func::Func>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)

Overloaded function.

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float

  2. dist(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, xyz: core::scoring::func::XYZ_Func) -> float

C++: core::scoring::constraints::AmbiguousNMRConstraint::dist(const class core::scoring::func::XYZ_Func &) const –> double

effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) int

C++: core::scoring::constraints::MultiConstraint::effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &) const –> unsigned long

empty_clone(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint) pyrosetta.rosetta.core.scoring.constraints.MultiConstraint

C++: core::scoring::constraints::AmbiguousNMRConstraint::empty_clone() const –> class std::shared_ptr<class core::scoring::constraints::MultiConstraint>

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, atom: pyrosetta.rosetta.core.id.AtomID, xyz: core::scoring::func::XYZ_Func, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t, weights: pyrosetta.rosetta.core.scoring.EMapVector) None

compute atom deriv

C++: core::scoring::constraints::AmbiguousNMRConstraint::fill_f1_f2(const class core::id::AtomID &, const class core::scoring::func::XYZ_Func &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const class core::scoring::EMapVector &) const –> void

get_func(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint) core::scoring::func::Func

Returns the func::Func object associated with this Constraint object.

C++: core::scoring::constraints::AmbiguousNMRConstraint::get_func() const –> const class core::scoring::func::Func &

member_constraints(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint) pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t

C++: core::scoring::constraints::MultiConstraint::member_constraints() const –> const class utility::vector1<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > > &

natoms(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint) int

number of atoms involved in this MultiConstraint container

C++: core::scoring::constraints::MultiConstraint::natoms() const –> unsigned long

read_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose) None
This method is totally redundant with read_def YAY

DON’T USE THIS ONE.. Most Constraint classes have not overloaded this one, but read_def ! OL

C++: core::scoring::constraints::Constraint::read_constraint(std::istream &, const class core::pose::Pose &) –> void

read_data(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream) None
initialize this Constraint from the given std::istream. It’s amazing

that there are three functions for doing this inside of Constraint.hh. SO WHAT IS THIS SUPPOSED TO DO ? not overloaded by e.g., AtomPairConstraint or CoordinateConstraint,

C++: core::scoring::constraints::Constraint::read_data(std::istream &) –> void

read_def(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: core::scoring::func::FuncFactory) None

read definition of a multiconstraint. Since a MultiConstraint is essentially a vector of

C++: core::scoring::constraints::AmbiguousNMRConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AmbiguousNMRConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)

Overloaded function.

  1. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

  2. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, map: pyrosetta.rosetta.core.id.SequenceMapping) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::MultiConstraint::remapped_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

residues(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint) pyrosetta.rosetta.utility.vector1_unsigned_long

C++: core::scoring::constraints::MultiConstraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) bool

C++: core::scoring::constraints::AmbiguousNMRConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)

Overloaded function.

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float

  2. score(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float

  3. score(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, xyz_func: core::scoring::func::XYZ_Func, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

compute score

C++: core::scoring::constraints::AmbiguousNMRConstraint::score(const class core::scoring::func::XYZ_Func &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

score_type(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.core.scoring.ScoreType

Returns the ScoreType that this Constraint object will use.

C++: core::scoring::constraints::Constraint::score_type() const –> const enum core::scoring::ScoreType &

set_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, setting: int) None

C++: core::scoring::constraints::MultiConstraint::set_effective_sequence_separation(unsigned long) –> void

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_derivatives(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::MultiConstraint::setup_for_scoring(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::MultiConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::constraints::AmbiguousNMRConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int, threshold: float) -> int

C++: core::scoring::constraints::AmbiguousNMRConstraint::show_violations(std::ostream &, const class core::pose::Pose &, unsigned long, double) const –> unsigned long

size(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint) int

number of constraints that are held by this %MultiConstraint

C++: core::scoring::constraints::MultiConstraint::size() const –> unsigned long

steal_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose) None

take coordinates, distances, angles, etc from given pose

C++: core::scoring::constraints::Constraint::steal_def(const class core::pose::Pose &) –> void

to_string(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) str
Convenience function, returns the results of show() as a string.

Not to be overriden by derived classes.

C++: core::scoring::constraints::Constraint::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint) str

C++: core::scoring::constraints::AmbiguousNMRConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraintCreator

Bases: pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator

Constraint creator for the AmbiguousNMRConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraintCreator

C++: core::scoring::constraints::AmbiguousNMRConstraintCreator::operator=(const class core::scoring::constraints::AmbiguousNMRConstraintCreator &) –> class core::scoring::constraints::AmbiguousNMRConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AmbiguousNMRConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraintCreator) str

C++: core::scoring::constraints::AmbiguousNMRConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint

Bases: pyrosetta.rosetta.core.scoring.constraints.Constraint

atom(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, n: int) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

choose_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, : numeric::random::RandomGenerator) int

C++: core::scoring::constraints::Constraint::choose_effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &, class numeric::random::RandomGenerator &) –> unsigned long

clone(*args, **kwargs)

Overloaded function.

  1. clone(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

  1. clone(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, func: pyrosetta.rosetta.core.scoring.func.Func) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::clone(class std::shared_ptr<class core::scoring::func::Func>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)

Overloaded function.

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float

  2. dist(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, xyz: core::scoring::func::XYZ_Func) -> float

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::dist(const class core::scoring::func::XYZ_Func &) const –> double

effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) int

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &) const –> unsigned long

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, atom: pyrosetta.rosetta.core.id.AtomID, xyz: core::scoring::func::XYZ_Func, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t, weights: pyrosetta.rosetta.core.scoring.EMapVector) None

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::fill_f1_f2(const class core::id::AtomID &, const class core::scoring::func::XYZ_Func &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const class core::scoring::EMapVector &) const –> void

get_func(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint) pyrosetta.rosetta.core.scoring.func.Func

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::get_func() const –> const class core::scoring::func::Func &

inv_dist6(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, xyz: core::scoring::func::XYZ_Func) float

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::inv_dist6(const class core::scoring::func::XYZ_Func &) const –> double

map_to_CEN(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, src: pyrosetta.rosetta.core.pose.Pose, centroid: pyrosetta.rosetta.core.pose.Pose, nr_mapped: int, map_atom: str) pyrosetta.rosetta.core.scoring.constraints.Constraint

returns AtomPairConstraint or AmbigousNMRDistanceConstraint (e.g. for GLY HA1-HA2 … )

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::map_to_CEN(const class core::pose::Pose &, const class core::pose::Pose &, unsigned long &, const std::string &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

multiplicity(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint) int

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::multiplicity() const –> unsigned long

natoms(*args, **kwargs)

Overloaded function.

  1. natoms(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint) -> int

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::natoms() const –> unsigned long

  1. natoms(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, i: int) -> int

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::natoms(unsigned long) const –> unsigned long

read_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose) None
This method is totally redundant with read_def YAY

DON’T USE THIS ONE.. Most Constraint classes have not overloaded this one, but read_def ! OL

C++: core::scoring::constraints::Constraint::read_constraint(std::istream &, const class core::pose::Pose &) –> void

read_data(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream) None
initialize this Constraint from the given std::istream. It’s amazing

that there are three functions for doing this inside of Constraint.hh. SO WHAT IS THIS SUPPOSED TO DO ? not overloaded by e.g., AtomPairConstraint or CoordinateConstraint,

C++: core::scoring::constraints::Constraint::read_data(std::istream &) –> void

read_def(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, in: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: core::scoring::func::FuncFactory) None

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)

Overloaded function.

  1. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

  2. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose, map: pyrosetta.rosetta.core.id.SequenceMapping) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

Copies the data from this Constraint into a new object and returns an OP

atoms are mapped to atoms with the same name in dest pose ( e.g. for switch from centroid to fullatom ) if a sequence_mapping is present it is used to map residue numbers .. nullptr = identity mapping to the new object. Intended to be implemented by derived classes.

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::remapped_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

resid(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, i: int) int

return residue number: i=1,2

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::resid(unsigned long) const –> unsigned long

residues(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the pose numbers of the residues involved in this constraint, in no particular order.

Used in determining one-body/two-body/multi-body status. For historical reasons, the default uses a simple protocol based on natoms()/atom() - feel free to reimplement more efficiently.

C++: core::scoring::constraints::Constraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) bool

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)

Overloaded function.

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float

  2. score(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float

  3. score(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, xyz: core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::score(const class core::scoring::func::XYZ_Func &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

score_type(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.core.scoring.ScoreType

Returns the ScoreType that this Constraint object will use.

C++: core::scoring::constraints::Constraint::score_type() const –> const enum core::scoring::ScoreType &

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_derivatives(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_scoring(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int, threshold: float) -> int

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::show_violations(std::ostream &, const class core::pose::Pose &, unsigned long, double) const –> unsigned long

steal_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose) None

take coordinates, distances, angles, etc from given pose

C++: core::scoring::constraints::Constraint::steal_def(const class core::pose::Pose &) –> void

to_string(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) str
Convenience function, returns the results of show() as a string.

Not to be overriden by derived classes.

C++: core::scoring::constraints::Constraint::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint) str

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraintCreator

Bases: pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator

Constraint creator for the AmbiguousNMRDistanceConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraintCreator

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraintCreator::operator=(const class core::scoring::constraints::AmbiguousNMRDistanceConstraintCreator &) –> class core::scoring::constraints::AmbiguousNMRDistanceConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraintCreator) str

C++: core::scoring::constraints::AmbiguousNMRDistanceConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.AngleConstraint

Bases: pyrosetta.rosetta.core.scoring.constraints.Constraint

An Angular Constraint.

angle(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, xyz1: pyrosetta.rosetta.numeric.xyzVector_double_t, xyz2: pyrosetta.rosetta.numeric.xyzVector_double_t, xyz3: pyrosetta.rosetta.numeric.xyzVector_double_t) float

compute

C++: core::scoring::constraints::AngleConstraint::angle(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) const –> double

atom(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, n: int) pyrosetta.rosetta.core.id.AtomID

return AtomID for atom 1,2,3

C++: core::scoring::constraints::AngleConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

atom1(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::AngleConstraint::atom1() const –> const class core::id::AtomID &

atom2(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::AngleConstraint::atom2() const –> const class core::id::AtomID &

atom3(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::AngleConstraint::atom3() const –> const class core::id::AtomID &

choose_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, : numeric::random::RandomGenerator) int

C++: core::scoring::constraints::Constraint::choose_effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &, class numeric::random::RandomGenerator &) –> unsigned long

clone(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AngleConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dfunc(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, theta: float) float

evaluate dfunc at theta

C++: core::scoring::constraints::AngleConstraint::dfunc(const double) const –> double

dist(*args, **kwargs)

Overloaded function.

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float

  2. dist(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, xyz: core::scoring::func::XYZ_Func) -> float

C++: core::scoring::constraints::AngleConstraint::dist(const class core::scoring::func::XYZ_Func &) const –> double

effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) int

C++: core::scoring::constraints::Constraint::effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &) const –> unsigned long

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, atom: pyrosetta.rosetta.core.id.AtomID, xyz: core::scoring::func::XYZ_Func, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t, weights: pyrosetta.rosetta.core.scoring.EMapVector) None

compute atom deriv

C++: core::scoring::constraints::AngleConstraint::fill_f1_f2(const class core::id::AtomID &, const class core::scoring::func::XYZ_Func &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const class core::scoring::EMapVector &) const –> void

func(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, theta: float) float

evaluate func at theta

C++: core::scoring::constraints::AngleConstraint::func(const double) const –> double

get_func(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint) pyrosetta.rosetta.core.scoring.func.Func

C++: core::scoring::constraints::AngleConstraint::get_func() const –> const class core::scoring::func::Func &

static helper(M: pyrosetta.rosetta.numeric.xyzVector_double_t, w: pyrosetta.rosetta.numeric.xyzVector_double_t, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) None

C++: core::scoring::constraints::AngleConstraint::helper(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) –> void

natoms(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint) int

number of atoms — always 3 for angles

C++: core::scoring::constraints::AngleConstraint::natoms() const –> unsigned long

p1_deriv(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) None

C++: core::scoring::constraints::AngleConstraint::p1_deriv(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

static p1_theta_deriv(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, f1: pyrosetta.rosetta.numeric.xyzVector_double_t, f2: pyrosetta.rosetta.numeric.xyzVector_double_t) None

C++: core::scoring::constraints::AngleConstraint::p1_theta_deriv(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) –> void

p2_deriv(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) None

C++: core::scoring::constraints::AngleConstraint::p2_deriv(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

read_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose) None
This method is totally redundant with read_def YAY

DON’T USE THIS ONE.. Most Constraint classes have not overloaded this one, but read_def ! OL

C++: core::scoring::constraints::Constraint::read_constraint(std::istream &, const class core::pose::Pose &) –> void

read_data(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream) None
initialize this Constraint from the given std::istream. It’s amazing

that there are three functions for doing this inside of Constraint.hh. SO WHAT IS THIS SUPPOSED TO DO ? not overloaded by e.g., AtomPairConstraint or CoordinateConstraint,

C++: core::scoring::constraints::Constraint::read_data(std::istream &) –> void

read_def(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: core::scoring::func::FuncFactory) None

read in constraint defiinition

C++: core::scoring::constraints::AngleConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AngleConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)

Overloaded function.

  1. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

  2. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose, map: pyrosetta.rosetta.core.id.SequenceMapping) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

Copies the data from this Constraint into a new object and returns an OP

atoms are mapped to atoms with the same name in dest pose ( e.g. for switch from centroid to fullatom ) if a sequence_mapping is present it is used to map residue numbers .. nullptr = identity mapping to the new object. Intended to be implemented by derived classes.

C++: core::scoring::constraints::AngleConstraint::remapped_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

residues(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the pose numbers of the residues involved in this constraint, in no particular order.

Used in determining one-body/two-body/multi-body status. For historical reasons, the default uses a simple protocol based on natoms()/atom() - feel free to reimplement more efficiently.

C++: core::scoring::constraints::Constraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) bool

C++: core::scoring::constraints::AngleConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)

Overloaded function.

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float

  2. score(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float

  3. score(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, xyz1: pyrosetta.rosetta.numeric.xyzVector_double_t, xyz2: pyrosetta.rosetta.numeric.xyzVector_double_t, xyz3: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

compute score

C++: core::scoring::constraints::AngleConstraint::score(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) const –> double

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, xyz: core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

compute score

C++: core::scoring::constraints::AngleConstraint::score(const class core::scoring::func::XYZ_Func &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, : pyrosetta.rosetta.core.conformation.Conformation) -> float

C++: core::scoring::constraints::AngleConstraint::score(const class core::conformation::Conformation &) const –> double

score_type(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.core.scoring.ScoreType

Returns the ScoreType that this Constraint object will use.

C++: core::scoring::constraints::Constraint::score_type() const –> const enum core::scoring::ScoreType &

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_derivatives(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::AngleConstraint::setup_for_scoring(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::AngleConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::constraints::AngleConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int, threshold: float) -> int

output violation of constraint to out - returns 1 if violated ( i.e., func.show_violations() > 0 )

C++: core::scoring::constraints::AngleConstraint::show_violations(std::ostream &, const class core::pose::Pose &, unsigned long, double) const –> unsigned long

steal_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose) None

take coordinates, distances, angles, etc from given pose

C++: core::scoring::constraints::Constraint::steal_def(const class core::pose::Pose &) –> void

to_string(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) str
Convenience function, returns the results of show() as a string.

Not to be overriden by derived classes.

C++: core::scoring::constraints::Constraint::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint) str

C++: core::scoring::constraints::AngleConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.AngleConstraintCreator

Bases: pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator

Constraint creator for the AngleConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.AngleConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.AngleConstraintCreator

C++: core::scoring::constraints::AngleConstraintCreator::operator=(const class core::scoring::constraints::AngleConstraintCreator &) –> class core::scoring::constraints::AngleConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AngleConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraintCreator) str

C++: core::scoring::constraints::AngleConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint

Bases: pyrosetta.rosetta.core.scoring.constraints.Constraint

atom(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, n: int) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::AtomPairConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

atom1(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::AtomPairConstraint::atom1() const –> const class core::id::AtomID &

atom2(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::AtomPairConstraint::atom2() const –> const class core::id::AtomID &

choose_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, : numeric::random::RandomGenerator) int

C++: core::scoring::constraints::Constraint::choose_effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &, class numeric::random::RandomGenerator &) –> unsigned long

clone(*args, **kwargs)

Overloaded function.

  1. clone(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

Create a deep copy of this %AtomPairConstraint, cloning its Func

C++: core::scoring::constraints::AtomPairConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

  1. clone(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, func: pyrosetta.rosetta.core.scoring.func.Func) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

Create a deep copy of this %AtomPairConstraint except that the copy should

use the input Func instead of its existing one.

C++: core::scoring::constraints::AtomPairConstraint::clone(class std::shared_ptr<class core::scoring::func::Func>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)

Overloaded function.

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float

C++: core::scoring::constraints::AtomPairConstraint::dist(const class core::pose::Pose &) const –> double

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, xyz: core::scoring::func::XYZ_Func) -> float

C++: core::scoring::constraints::AtomPairConstraint::dist(const class core::scoring::func::XYZ_Func &) const –> double

effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) int

C++: core::scoring::constraints::AtomPairConstraint::effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &) const –> unsigned long

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, atom: pyrosetta.rosetta.core.id.AtomID, xyz: core::scoring::func::XYZ_Func, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t, weights: pyrosetta.rosetta.core.scoring.EMapVector) None

C++: core::scoring::constraints::AtomPairConstraint::fill_f1_f2(const class core::id::AtomID &, const class core::scoring::func::XYZ_Func &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const class core::scoring::EMapVector &) const –> void

get_func(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint) pyrosetta.rosetta.core.scoring.func.Func

C++: core::scoring::constraints::AtomPairConstraint::get_func() const –> const class core::scoring::func::Func &

natoms(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint) int

C++: core::scoring::constraints::AtomPairConstraint::natoms() const –> unsigned long

read_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose) None
This method is totally redundant with read_def YAY

DON’T USE THIS ONE.. Most Constraint classes have not overloaded this one, but read_def ! OL

C++: core::scoring::constraints::Constraint::read_constraint(std::istream &, const class core::pose::Pose &) –> void

read_data(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream) None
initialize this Constraint from the given std::istream. It’s amazing

that there are three functions for doing this inside of Constraint.hh. SO WHAT IS THIS SUPPOSED TO DO ? not overloaded by e.g., AtomPairConstraint or CoordinateConstraint,

C++: core::scoring::constraints::Constraint::read_data(std::istream &) –> void

read_def(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, in: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: core::scoring::func::FuncFactory) None

C++: core::scoring::constraints::AtomPairConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AtomPairConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)

Overloaded function.

  1. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

  2. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose, map: pyrosetta.rosetta.core.id.SequenceMapping) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

Copies the data from this Constraint into a new object and returns an OP

atoms are mapped to atoms with the same name in dest pose ( e.g. for switch from centroid to fullatom ) if a sequence_mapping is present it is used to map residue numbers .. nullptr = identity mapping to the new object. Intended to be implemented by derived classes.

C++: core::scoring::constraints::AtomPairConstraint::remapped_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

residues(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the pose numbers of the residues involved in this constraint, in no particular order.

Used in determining one-body/two-body/multi-body status. For historical reasons, the default uses a simple protocol based on natoms()/atom() - feel free to reimplement more efficiently.

C++: core::scoring::constraints::Constraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) bool

C++: core::scoring::constraints::AtomPairConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)

Overloaded function.

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float

  2. score(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, xyz1: pyrosetta.rosetta.numeric.xyzVector_double_t, xyz2: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: core::scoring::constraints::AtomPairConstraint::score(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) const –> double

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, xyz: core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::AtomPairConstraint::score(const class core::scoring::func::XYZ_Func &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float

C++: core::scoring::constraints::AtomPairConstraint::score(const class core::pose::Pose &) const –> double

score_type(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.core.scoring.ScoreType

Returns the ScoreType that this Constraint object will use.

C++: core::scoring::constraints::Constraint::score_type() const –> const enum core::scoring::ScoreType &

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_derivatives(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::AtomPairConstraint::setup_for_scoring(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::AtomPairConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::constraints::AtomPairConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int, threshold: float) -> int

C++: core::scoring::constraints::AtomPairConstraint::show_violations(std::ostream &, const class core::pose::Pose &, unsigned long, double) const –> unsigned long

steal_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose) None

take coordinates, distances, angles, etc from given pose

C++: core::scoring::constraints::Constraint::steal_def(const class core::pose::Pose &) –> void

to_string(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) str
Convenience function, returns the results of show() as a string.

Not to be overriden by derived classes.

C++: core::scoring::constraints::Constraint::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint) str

C++: core::scoring::constraints::AtomPairConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraintCreator

Bases: pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator

Constraint creator for the AtomPairConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraintCreator

C++: core::scoring::constraints::AtomPairConstraintCreator::operator=(const class core::scoring::constraints::AtomPairConstraintCreator &) –> class core::scoring::constraints::AtomPairConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AtomPairConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraintCreator) str

C++: core::scoring::constraints::AtomPairConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint

Bases: pyrosetta.rosetta.core.scoring.constraints.Constraint

atom(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, ii: int) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::AtomToAxisConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

calc_xyzs(*args, **kwargs)

Overloaded function.

  1. calc_xyzs(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.XYZs

C++: core::scoring::constraints::AtomToAxisConstraint::calc_xyzs(const class core::pose::Pose &) const –> struct core::scoring::constraints::XYZs

  1. calc_xyzs(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, xyz: core::scoring::func::XYZ_Func) -> pyrosetta.rosetta.core.scoring.constraints.XYZs

C++: core::scoring::constraints::AtomToAxisConstraint::calc_xyzs(const class core::scoring::func::XYZ_Func &) const –> struct core::scoring::constraints::XYZs

choose_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, : numeric::random::RandomGenerator) int

C++: core::scoring::constraints::Constraint::choose_effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &, class numeric::random::RandomGenerator &) –> unsigned long

clone(*args, **kwargs)

Overloaded function.

  1. clone(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

Create a deep copy of this %AtomToAxisConstraint, cloning its Func

C++: core::scoring::constraints::AtomToAxisConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

  1. clone(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, func: pyrosetta.rosetta.core.scoring.func.Func) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

Create a deep copy of this %AtomToAxisConstraint except that the copy should

use the input Func instead of its existing one.

C++: core::scoring::constraints::AtomToAxisConstraint::clone(class std::shared_ptr<class core::scoring::func::Func>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)

Overloaded function.

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float

C++: core::scoring::constraints::AtomToAxisConstraint::dist(const class core::pose::Pose &) const –> double

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, xyz: core::scoring::func::XYZ_Func) -> float

C++: core::scoring::constraints::AtomToAxisConstraint::dist(const class core::scoring::func::XYZ_Func &) const –> double

effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) int

C++: core::scoring::constraints::Constraint::effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &) const –> unsigned long

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, atom: pyrosetta.rosetta.core.id.AtomID, xyz: core::scoring::func::XYZ_Func, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t, weights: pyrosetta.rosetta.core.scoring.EMapVector) None

C++: core::scoring::constraints::AtomToAxisConstraint::fill_f1_f2(const class core::id::AtomID &, const class core::scoring::func::XYZ_Func &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const class core::scoring::EMapVector &) const –> void

get_atom(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::AtomToAxisConstraint::get_atom() const –> const class core::id::AtomID &

get_func(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint) pyrosetta.rosetta.core.scoring.func.Func

C++: core::scoring::constraints::AtomToAxisConstraint::get_func() const –> const class core::scoring::func::Func &

natoms(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint) int

C++: core::scoring::constraints::AtomToAxisConstraint::natoms() const –> unsigned long

read_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose) None
This method is totally redundant with read_def YAY

DON’T USE THIS ONE.. Most Constraint classes have not overloaded this one, but read_def ! OL

C++: core::scoring::constraints::Constraint::read_constraint(std::istream &, const class core::pose::Pose &) –> void

read_data(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream) None
initialize this Constraint from the given std::istream. It’s amazing

that there are three functions for doing this inside of Constraint.hh. SO WHAT IS THIS SUPPOSED TO DO ? not overloaded by e.g., AtomPairConstraint or CoordinateConstraint,

C++: core::scoring::constraints::Constraint::read_data(std::istream &) –> void

read_def(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, in: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: core::scoring::func::FuncFactory) None

C++: core::scoring::constraints::AtomToAxisConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::AtomToAxisConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)

Overloaded function.

  1. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

  2. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose, map: pyrosetta.rosetta.core.id.SequenceMapping) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

Copies the data from this Constraint into a new object and returns an OP

atoms are mapped to atoms with the same name in dest pose ( e.g. for switch from centroid to fullatom ) if a sequence_mapping is present it is used to map residue numbers .. nullptr = identity mapping to the new object. Intended to be implemented by derived classes.

C++: core::scoring::constraints::AtomToAxisConstraint::remapped_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

residues(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the pose numbers of the residues involved in this constraint, in no particular order.

Used in determining one-body/two-body/multi-body status. For historical reasons, the default uses a simple protocol based on natoms()/atom() - feel free to reimplement more efficiently.

C++: core::scoring::constraints::Constraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) bool

C++: core::scoring::constraints::AtomToAxisConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)

Overloaded function.

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float

  2. score(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, xyz1: pyrosetta.rosetta.numeric.xyzVector_double_t, xyz2: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: core::scoring::constraints::AtomToAxisConstraint::score(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) const –> double

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, xyz: core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::AtomToAxisConstraint::score(const class core::scoring::func::XYZ_Func &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float

C++: core::scoring::constraints::AtomToAxisConstraint::score(const class core::pose::Pose &) const –> double

score_type(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.core.scoring.ScoreType

Returns the ScoreType that this Constraint object will use.

C++: core::scoring::constraints::Constraint::score_type() const –> const enum core::scoring::ScoreType &

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_derivatives(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::AtomToAxisConstraint::setup_for_scoring(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::AtomToAxisConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::constraints::AtomToAxisConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int, threshold: float) -> int

C++: core::scoring::constraints::AtomToAxisConstraint::show_violations(std::ostream &, const class core::pose::Pose &, unsigned long, double) const –> unsigned long

steal_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose) None

take coordinates, distances, angles, etc from given pose

C++: core::scoring::constraints::Constraint::steal_def(const class core::pose::Pose &) –> void

to_string(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) str
Convenience function, returns the results of show() as a string.

Not to be overriden by derived classes.

C++: core::scoring::constraints::Constraint::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint) str

C++: core::scoring::constraints::AtomToAxisConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint

Bases: pyrosetta.rosetta.core.scoring.constraints.Constraint

This constraint favors the backbone landing on a “stub” backbone, which puts the sidechain in a pre-determined desirable location

atom(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint, index: int) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::BackboneStubConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

choose_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, : numeric::random::RandomGenerator) int

C++: core::scoring::constraints::Constraint::choose_effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &, class numeric::random::RandomGenerator &) –> unsigned long

clone(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::BackboneStubConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)

Overloaded function.

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float

  2. dist(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint, : core::scoring::func::XYZ_Func) -> float

“Distance” for BackboneStubConstraint isn’t all that simple

C++: core::scoring::constraints::BackboneStubConstraint::dist(const class core::scoring::func::XYZ_Func &) const –> double

effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) int

C++: core::scoring::constraints::Constraint::effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &) const –> unsigned long

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint, atom: pyrosetta.rosetta.core.id.AtomID, xyz: core::scoring::func::XYZ_Func, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t, weights: pyrosetta.rosetta.core.scoring.EMapVector) None

C++: core::scoring::constraints::BackboneStubConstraint::fill_f1_f2(const class core::id::AtomID &, const class core::scoring::func::XYZ_Func &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const class core::scoring::EMapVector &) const –> void

get_func(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) core::scoring::func::Func

Returns the func::Func object associated with this Constraint object.

C++: core::scoring::constraints::Constraint::get_func() const –> const class core::scoring::func::Func &

natoms(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint) int

C++: core::scoring::constraints::BackboneStubConstraint::natoms() const –> unsigned long

read_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose) None
This method is totally redundant with read_def YAY

DON’T USE THIS ONE.. Most Constraint classes have not overloaded this one, but read_def ! OL

C++: core::scoring::constraints::Constraint::read_constraint(std::istream &, const class core::pose::Pose &) –> void

read_data(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream) None
initialize this Constraint from the given std::istream. It’s amazing

that there are three functions for doing this inside of Constraint.hh. SO WHAT IS THIS SUPPOSED TO DO ? not overloaded by e.g., AtomPairConstraint or CoordinateConstraint,

C++: core::scoring::constraints::Constraint::read_data(std::istream &) –> void

read_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose, : core::scoring::func::FuncFactory) None
Reads the definition of a Constraint from the given std::istream,

using the given Pose, and the given func::FuncFactory. This method is intended to be overridden by derived classes if they’d like to use the ConstraintIO machinery.

C++: core::scoring::constraints::Constraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint
apply a resid remapping to this constraint, returns the remapped

constraint Does this return an owning pointer to this constraint or a copy? Documentation would be nice.

C++: core::scoring::constraints::Constraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)

Overloaded function.

  1. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

  2. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose, map: pyrosetta.rosetta.core.id.SequenceMapping) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

Copies the data from this Constraint into a new object and returns an OP

atoms are mapped to atoms with the same name in dest pose ( e.g. for switch from centroid to fullatom ) if a sequence_mapping is present it is used to map residue numbers .. nullptr = identity mapping to the new object. Intended to be implemented by derived classes.

C++: core::scoring::constraints::BackboneStubConstraint::remapped_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

residues(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the pose numbers of the residues involved in this constraint, in no particular order.

Used in determining one-body/two-body/multi-body status. For historical reasons, the default uses a simple protocol based on natoms()/atom() - feel free to reimplement more efficiently.

C++: core::scoring::constraints::Constraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) bool

C++: core::scoring::constraints::BackboneStubConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)

Overloaded function.

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float

  2. score(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float

  3. score(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint, xyz_func: core::scoring::func::XYZ_Func, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::BackboneStubConstraint::score(const class core::scoring::func::XYZ_Func &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

score_type(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.core.scoring.ScoreType

Returns the ScoreType that this Constraint object will use.

C++: core::scoring::constraints::Constraint::score_type() const –> const enum core::scoring::ScoreType &

seqpos(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint) int

returns the private member seqpos_

C++: core::scoring::constraints::BackboneStubConstraint::seqpos() const –> unsigned long

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_derivatives(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_scoring(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::BackboneStubConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose) None
Prints the definition of a Constraint to the given std::ostream,

using the given Pose, and the given func::FuncFactory. This method is intended to be overridden by derived classes if they’d like to use the ConstraintIO machinery. It’s also not clear why this method takes a Pose, other than to be symmetric with read_def.

C++: core::scoring::constraints::Constraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int, threshold: float) -> int

Prints the violations of this constraint to the given

std::ostream. What are violations? It’s not defined, and it depends on the constraint and the function! also - wtf is threshold? it was defined as a Size in CoordinateConstraint, I don’t know which definition is the right one. Documentation would be nice …

C++: core::scoring::constraints::Constraint::show_violations(std::ostream &, const class core::pose::Pose &, unsigned long, double) const –> unsigned long

steal_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose) None

take coordinates, distances, angles, etc from given pose

C++: core::scoring::constraints::Constraint::steal_def(const class core::pose::Pose &) –> void

to_string(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) str
Convenience function, returns the results of show() as a string.

Not to be overriden by derived classes.

C++: core::scoring::constraints::Constraint::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint) str

C++: core::scoring::constraints::BackboneStubConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint

Bases: pyrosetta.rosetta.core.scoring.constraints.Constraint

This constraint favors the backbone landing on a “stub” backbone, which puts the sidechain in a pre-determined desirable location

atom(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint, index: int) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::BackboneStubLinearConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

choose_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, : numeric::random::RandomGenerator) int

C++: core::scoring::constraints::Constraint::choose_effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &, class numeric::random::RandomGenerator &) –> unsigned long

clone(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::BackboneStubLinearConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)

Overloaded function.

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float

  2. dist(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint, : core::scoring::func::XYZ_Func) -> float

“Distance” for BackboneStubLinearConstraint isn’t all that simple

C++: core::scoring::constraints::BackboneStubLinearConstraint::dist(const class core::scoring::func::XYZ_Func &) const –> double

effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) int

C++: core::scoring::constraints::Constraint::effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &) const –> unsigned long

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint, atom: pyrosetta.rosetta.core.id.AtomID, xyz: core::scoring::func::XYZ_Func, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t, weights: pyrosetta.rosetta.core.scoring.EMapVector) None

C++: core::scoring::constraints::BackboneStubLinearConstraint::fill_f1_f2(const class core::id::AtomID &, const class core::scoring::func::XYZ_Func &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const class core::scoring::EMapVector &) const –> void

get_func(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) core::scoring::func::Func

Returns the func::Func object associated with this Constraint object.

C++: core::scoring::constraints::Constraint::get_func() const –> const class core::scoring::func::Func &

natoms(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint) int

C++: core::scoring::constraints::BackboneStubLinearConstraint::natoms() const –> unsigned long

read_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose) None
This method is totally redundant with read_def YAY

DON’T USE THIS ONE.. Most Constraint classes have not overloaded this one, but read_def ! OL

C++: core::scoring::constraints::Constraint::read_constraint(std::istream &, const class core::pose::Pose &) –> void

read_data(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream) None
initialize this Constraint from the given std::istream. It’s amazing

that there are three functions for doing this inside of Constraint.hh. SO WHAT IS THIS SUPPOSED TO DO ? not overloaded by e.g., AtomPairConstraint or CoordinateConstraint,

C++: core::scoring::constraints::Constraint::read_data(std::istream &) –> void

read_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose, : core::scoring::func::FuncFactory) None
Reads the definition of a Constraint from the given std::istream,

using the given Pose, and the given func::FuncFactory. This method is intended to be overridden by derived classes if they’d like to use the ConstraintIO machinery.

C++: core::scoring::constraints::Constraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint
apply a resid remapping to this constraint, returns the remapped

constraint Does this return an owning pointer to this constraint or a copy? Documentation would be nice.

C++: core::scoring::constraints::Constraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)

Overloaded function.

  1. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

  2. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose, map: pyrosetta.rosetta.core.id.SequenceMapping) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

Copies the data from this Constraint into a new object and returns an OP

atoms are mapped to atoms with the same name in dest pose ( e.g. for switch from centroid to fullatom ) if a sequence_mapping is present it is used to map residue numbers .. nullptr = identity mapping to the new object. Intended to be implemented by derived classes.

C++: core::scoring::constraints::BackboneStubLinearConstraint::remapped_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

residues(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the pose numbers of the residues involved in this constraint, in no particular order.

Used in determining one-body/two-body/multi-body status. For historical reasons, the default uses a simple protocol based on natoms()/atom() - feel free to reimplement more efficiently.

C++: core::scoring::constraints::Constraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) bool

C++: core::scoring::constraints::BackboneStubLinearConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)

Overloaded function.

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float

  2. score(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float

  3. score(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint, xyz_func: core::scoring::func::XYZ_Func, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::BackboneStubLinearConstraint::score(const class core::scoring::func::XYZ_Func &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

score_type(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.core.scoring.ScoreType

Returns the ScoreType that this Constraint object will use.

C++: core::scoring::constraints::Constraint::score_type() const –> const enum core::scoring::ScoreType &

seqpos(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint) int

returns the private member seqpos_

C++: core::scoring::constraints::BackboneStubLinearConstraint::seqpos() const –> unsigned long

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_derivatives(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_scoring(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::BackboneStubLinearConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose) None
Prints the definition of a Constraint to the given std::ostream,

using the given Pose, and the given func::FuncFactory. This method is intended to be overridden by derived classes if they’d like to use the ConstraintIO machinery. It’s also not clear why this method takes a Pose, other than to be symmetric with read_def.

C++: core::scoring::constraints::Constraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int, threshold: float) -> int

Prints the violations of this constraint to the given

std::ostream. What are violations? It’s not defined, and it depends on the constraint and the function! also - wtf is threshold? it was defined as a Size in CoordinateConstraint, I don’t know which definition is the right one. Documentation would be nice …

C++: core::scoring::constraints::Constraint::show_violations(std::ostream &, const class core::pose::Pose &, unsigned long, double) const –> unsigned long

steal_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose) None

take coordinates, distances, angles, etc from given pose

C++: core::scoring::constraints::Constraint::steal_def(const class core::pose::Pose &) –> void

to_string(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) str
Convenience function, returns the results of show() as a string.

Not to be overriden by derived classes.

C++: core::scoring::constraints::Constraint::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint) str

C++: core::scoring::constraints::BackboneStubLinearConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint

Bases: pyrosetta.rosetta.core.scoring.constraints.Constraint

atom(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, n: int) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::BasePairConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

choose_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, : numeric::random::RandomGenerator) int

C++: core::scoring::constraints::Constraint::choose_effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &, class numeric::random::RandomGenerator &) –> unsigned long

clone(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::BasePairConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

constraints(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint) pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t

C++: core::scoring::constraints::BasePairConstraint::constraints() const –> const class utility::vector1<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > > &

dist(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, : core::scoring::func::XYZ_Func) float

C++: core::scoring::constraints::BasePairConstraint::dist(const class core::scoring::func::XYZ_Func &) const –> double

effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) int

C++: core::scoring::constraints::Constraint::effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &) const –> unsigned long

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, atom: pyrosetta.rosetta.core.id.AtomID, xyz: core::scoring::func::XYZ_Func, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t, weights: pyrosetta.rosetta.core.scoring.EMapVector) None

compute atom deriv

C++: core::scoring::constraints::BasePairConstraint::fill_f1_f2(const class core::id::AtomID &, const class core::scoring::func::XYZ_Func &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const class core::scoring::EMapVector &) const –> void

get_func(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) core::scoring::func::Func

Returns the func::Func object associated with this Constraint object.

C++: core::scoring::constraints::Constraint::get_func() const –> const class core::scoring::func::Func &

init_subsidiary_constraints(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::constraints::BasePairConstraint::init_subsidiary_constraints(const class core::pose::Pose &) –> void

natoms(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint) int

number of atoms involved in this BasePairConstraint

C++: core::scoring::constraints::BasePairConstraint::natoms() const –> unsigned long

read_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose) None
This method is totally redundant with read_def YAY

DON’T USE THIS ONE.. Most Constraint classes have not overloaded this one, but read_def ! OL

C++: core::scoring::constraints::Constraint::read_constraint(std::istream &, const class core::pose::Pose &) –> void

read_data(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream) None
initialize this Constraint from the given std::istream. It’s amazing

that there are three functions for doing this inside of Constraint.hh. SO WHAT IS THIS SUPPOSED TO DO ? not overloaded by e.g., AtomPairConstraint or CoordinateConstraint,

C++: core::scoring::constraints::Constraint::read_data(std::istream &) –> void

read_def(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: core::scoring::func::FuncFactory) None

read in constraint defiinition

C++: core::scoring::constraints::BasePairConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::BasePairConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose, smap: pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::BasePairConstraint::remapped_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

residues(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the pose numbers of the residues involved in this constraint, in no particular order.

Used in determining one-body/two-body/multi-body status. For historical reasons, the default uses a simple protocol based on natoms()/atom() - feel free to reimplement more efficiently.

C++: core::scoring::constraints::Constraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) bool

C++: core::scoring::constraints::BasePairConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, xyz_func: core::scoring::func::XYZ_Func, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) None

compute score

C++: core::scoring::constraints::BasePairConstraint::score(const class core::scoring::func::XYZ_Func &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

score_type(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.core.scoring.ScoreType

Returns the ScoreType that this Constraint object will use.

C++: core::scoring::constraints::Constraint::score_type() const –> const enum core::scoring::ScoreType &

set_constraints(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, setting: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) None

C++: core::scoring::constraints::BasePairConstraint::set_constraints(const class utility::vector1<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > > &) –> void

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_derivatives(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_scoring(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::BasePairConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::constraints::BasePairConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int, threshold: float) -> int

C++: core::scoring::constraints::BasePairConstraint::show_violations(std::ostream &, const class core::pose::Pose &, unsigned long, double) const –> unsigned long

steal_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose) None

take coordinates, distances, angles, etc from given pose

C++: core::scoring::constraints::Constraint::steal_def(const class core::pose::Pose &) –> void

to_string(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) str
Convenience function, returns the results of show() as a string.

Not to be overriden by derived classes.

C++: core::scoring::constraints::Constraint::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint) str

C++: core::scoring::constraints::BasePairConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.BasePairConstraintCreator

Bases: pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator

Constraint creator for the BasePairConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.BasePairConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.BasePairConstraintCreator

C++: core::scoring::constraints::BasePairConstraintCreator::operator=(const class core::scoring::constraints::BasePairConstraintCreator &) –> class core::scoring::constraints::BasePairConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::BasePairConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraintCreator) str

C++: core::scoring::constraints::BasePairConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint

Bases: pyrosetta.rosetta.core.scoring.constraints.Constraint

constraint on dihedral angle formed by 4 points

atom(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint, n: int) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::BigBinConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

bin(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint) str

C++: core::scoring::constraints::BigBinConstraint::bin() const –> char

choose_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, : numeric::random::RandomGenerator) int

C++: core::scoring::constraints::Constraint::choose_effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &, class numeric::random::RandomGenerator &) –> unsigned long

clone(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::BigBinConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)

Overloaded function.

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float

  2. dist(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint, : core::scoring::func::XYZ_Func) -> float

BigBinConstraints don’t have a single distance

C++: core::scoring::constraints::BigBinConstraint::dist(const class core::scoring::func::XYZ_Func &) const –> double

effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) int

C++: core::scoring::constraints::Constraint::effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &) const –> unsigned long

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint, : pyrosetta.rosetta.core.id.AtomID, xyz: core::scoring::func::XYZ_Func, : pyrosetta.rosetta.numeric.xyzVector_double_t, : pyrosetta.rosetta.numeric.xyzVector_double_t, : pyrosetta.rosetta.core.scoring.EMapVector) None

C++: core::scoring::constraints::BigBinConstraint::fill_f1_f2(const class core::id::AtomID &, const class core::scoring::func::XYZ_Func &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const class core::scoring::EMapVector &) const –> void

get_func(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) core::scoring::func::Func

Returns the func::Func object associated with this Constraint object.

C++: core::scoring::constraints::Constraint::get_func() const –> const class core::scoring::func::Func &

natoms(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint) int

C++: core::scoring::constraints::BigBinConstraint::natoms() const –> unsigned long

read_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose) None
This method is totally redundant with read_def YAY

DON’T USE THIS ONE.. Most Constraint classes have not overloaded this one, but read_def ! OL

C++: core::scoring::constraints::Constraint::read_constraint(std::istream &, const class core::pose::Pose &) –> void

read_data(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream) None
initialize this Constraint from the given std::istream. It’s amazing

that there are three functions for doing this inside of Constraint.hh. SO WHAT IS THIS SUPPOSED TO DO ? not overloaded by e.g., AtomPairConstraint or CoordinateConstraint,

C++: core::scoring::constraints::Constraint::read_data(std::istream &) –> void

read_def(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint, in: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: core::scoring::func::FuncFactory) None

C++: core::scoring::constraints::BigBinConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint
apply a resid remapping to this constraint, returns the remapped

constraint Does this return an owning pointer to this constraint or a copy? Documentation would be nice.

C++: core::scoring::constraints::Constraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, map: pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint
Copies the data from this Constraint into a new object and returns

an OP atoms are mapped to atoms with the same name in dest pose ( e.g. for switch from centroid to fullatom ) if a sequence_mapping is present it is used to map residue numbers .. NULL = identity mapping to the new object. Intended to be implemented by derived classes.

C++: core::scoring::constraints::Constraint::remapped_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

res(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint) int

C++: core::scoring::constraints::BigBinConstraint::res() const –> unsigned long

residues(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the pose numbers of the residues involved in this constraint, in no particular order.

Used in determining one-body/two-body/multi-body status. For historical reasons, the default uses a simple protocol based on natoms()/atom() - feel free to reimplement more efficiently.

C++: core::scoring::constraints::Constraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) bool

C++: core::scoring::constraints::BigBinConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)

Overloaded function.

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float

  2. score(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float

  3. score(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint, xyz: core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::BigBinConstraint::score(const class core::scoring::func::XYZ_Func &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

score_type(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.core.scoring.ScoreType

Returns the ScoreType that this Constraint object will use.

C++: core::scoring::constraints::Constraint::score_type() const –> const enum core::scoring::ScoreType &

sdev(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint) float

C++: core::scoring::constraints::BigBinConstraint::sdev() const –> double

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_derivatives(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_scoring(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::BigBinConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose) None
Prints the definition of a Constraint to the given std::ostream,

using the given Pose, and the given func::FuncFactory. This method is intended to be overridden by derived classes if they’d like to use the ConstraintIO machinery. It’s also not clear why this method takes a Pose, other than to be symmetric with read_def.

C++: core::scoring::constraints::Constraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int, threshold: float) -> int

Prints the violations of this constraint to the given

std::ostream. What are violations? It’s not defined, and it depends on the constraint and the function! also - wtf is threshold? it was defined as a Size in CoordinateConstraint, I don’t know which definition is the right one. Documentation would be nice …

C++: core::scoring::constraints::Constraint::show_violations(std::ostream &, const class core::pose::Pose &, unsigned long, double) const –> unsigned long

steal_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose) None

take coordinates, distances, angles, etc from given pose

C++: core::scoring::constraints::Constraint::steal_def(const class core::pose::Pose &) –> void

to_string(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) str
Convenience function, returns the results of show() as a string.

Not to be overriden by derived classes.

C++: core::scoring::constraints::Constraint::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint) str

C++: core::scoring::constraints::BigBinConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.BigBinConstraintCreator

Bases: pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator

Constraint creator for the BigBinConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.BigBinConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.BigBinConstraintCreator

C++: core::scoring::constraints::BigBinConstraintCreator::operator=(const class core::scoring::constraints::BigBinConstraintCreator &) –> class core::scoring::constraints::BigBinConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::BigBinConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraintCreator) str

C++: core::scoring::constraints::BigBinConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.BoundFunc

Bases: pyrosetta.rosetta.core.scoring.func.Func

assign(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc, : pyrosetta.rosetta.core.scoring.constraints.BoundFunc) pyrosetta.rosetta.core.scoring.constraints.BoundFunc

C++: core::scoring::constraints::BoundFunc::operator=(const class core::scoring::constraints::BoundFunc &) –> class core::scoring::constraints::BoundFunc &

clone(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc) pyrosetta.rosetta.core.scoring.func.Func

C++: core::scoring::constraints::BoundFunc::clone() const –> class std::shared_ptr<class core::scoring::func::Func>

dfunc(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc, x: float) float

C++: core::scoring::constraints::BoundFunc::dfunc(const double) const –> double

estimate_dfunc(*args, **kwargs)

Overloaded function.

  1. estimate_dfunc(self: pyrosetta.rosetta.core.scoring.func.Func, r: float) -> float

Estimates the derivative of this function at a given radius by

calculating the slope of the secant line from func(r) and func(r+1e-05).

C++: core::scoring::func::Func::estimate_dfunc(const double) const –> double

  1. estimate_dfunc(self: pyrosetta.rosetta.core.scoring.func.Func, r: float, h: float) -> float

Estimates the derivative of this function at a given radius by

calculating the slope of the secant line from func(r) and func(r+h).

C++: core::scoring::func::Func::estimate_dfunc(const double, const double) const –> double

func(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc, x: float) float

C++: core::scoring::constraints::BoundFunc::func(const double) const –> double

lb(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc) float

C++: core::scoring::constraints::BoundFunc::lb() const –> double

read_data(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc, : pyrosetta.rosetta.std.istream) None

C++: core::scoring::constraints::BoundFunc::read_data(std::istream &) –> void

rswitch(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc) float

C++: core::scoring::constraints::BoundFunc::rswitch() const –> double

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc, other: pyrosetta.rosetta.core.scoring.func.Func) bool

C++: core::scoring::constraints::BoundFunc::same_type_as_me(const class core::scoring::func::Func &) const –> bool

sd(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc) float

C++: core::scoring::constraints::BoundFunc::sd() const –> double

show(self: pyrosetta.rosetta.core.scoring.func.Func, out: pyrosetta.rosetta.std.ostream) None
Prints out space-delimited columns for r, func, dfunc and

dfunc_est. The values for func, dfunc and dfunc_est are plotted as a function of r, which is varied from 2-20 in steps of 0.5. The value for dfunc_est is the estimated by the method estimate_dfunc( r ).

C++: core::scoring::func::Func::show(std::ostream &) const –> void

show_definition(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::BoundFunc::show_definition(std::ostream &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc, out: pyrosetta.rosetta.std.ostream, x: float, verbose_level: int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc, out: pyrosetta.rosetta.std.ostream, x: float, verbose_level: int, threshold: float) -> int

C++: core::scoring::constraints::BoundFunc::show_violations(std::ostream &, double, unsigned long, double) const –> unsigned long

type(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc) str

C++: core::scoring::constraints::BoundFunc::type() const –> std::string

ub(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc) float

C++: core::scoring::constraints::BoundFunc::ub() const –> double

class pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint

Bases: pyrosetta.rosetta.core.scoring.constraints.Constraint

A Constant Constraint.

atom(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint, n: int) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::ConstantConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

choose_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, : numeric::random::RandomGenerator) int

C++: core::scoring::constraints::Constraint::choose_effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &, class numeric::random::RandomGenerator &) –> unsigned long

clone(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::ConstantConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)

Overloaded function.

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float

  2. dist(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint, xyz: core::scoring::func::XYZ_Func) -> float

C++: core::scoring::constraints::ConstantConstraint::dist(const class core::scoring::func::XYZ_Func &) const –> double

effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) int

C++: core::scoring::constraints::Constraint::effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &) const –> unsigned long

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint, : pyrosetta.rosetta.core.id.AtomID, : core::scoring::func::XYZ_Func, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t, : pyrosetta.rosetta.core.scoring.EMapVector) None

compute atom deriv

C++: core::scoring::constraints::ConstantConstraint::fill_f1_f2(const class core::id::AtomID &, const class core::scoring::func::XYZ_Func &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const class core::scoring::EMapVector &) const –> void

get_func(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) core::scoring::func::Func

Returns the func::Func object associated with this Constraint object.

C++: core::scoring::constraints::Constraint::get_func() const –> const class core::scoring::func::Func &

natoms(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint) int

number of atoms — zero

C++: core::scoring::constraints::ConstantConstraint::natoms() const –> unsigned long

read_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose) None
This method is totally redundant with read_def YAY

DON’T USE THIS ONE.. Most Constraint classes have not overloaded this one, but read_def ! OL

C++: core::scoring::constraints::Constraint::read_constraint(std::istream &, const class core::pose::Pose &) –> void

read_data(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream) None
initialize this Constraint from the given std::istream. It’s amazing

that there are three functions for doing this inside of Constraint.hh. SO WHAT IS THIS SUPPOSED TO DO ? not overloaded by e.g., AtomPairConstraint or CoordinateConstraint,

C++: core::scoring::constraints::Constraint::read_data(std::istream &) –> void

read_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose, : core::scoring::func::FuncFactory) None
Reads the definition of a Constraint from the given std::istream,

using the given Pose, and the given func::FuncFactory. This method is intended to be overridden by derived classes if they’d like to use the ConstraintIO machinery.

C++: core::scoring::constraints::Constraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint
apply a resid remapping to this constraint, returns the remapped

constraint Does this return an owning pointer to this constraint or a copy? Documentation would be nice.

C++: core::scoring::constraints::Constraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, map: pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint
Copies the data from this Constraint into a new object and returns

an OP atoms are mapped to atoms with the same name in dest pose ( e.g. for switch from centroid to fullatom ) if a sequence_mapping is present it is used to map residue numbers .. NULL = identity mapping to the new object. Intended to be implemented by derived classes.

C++: core::scoring::constraints::Constraint::remapped_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

residues(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the pose numbers of the residues involved in this constraint, in no particular order.

Used in determining one-body/two-body/multi-body status. For historical reasons, the default uses a simple protocol based on natoms()/atom() - feel free to reimplement more efficiently.

C++: core::scoring::constraints::Constraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) bool

C++: core::scoring::constraints::ConstantConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)

Overloaded function.

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float

  2. score(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float

  3. score(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint) -> float

compute score

C++: core::scoring::constraints::ConstantConstraint::score() const –> double

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

compute score

C++: core::scoring::constraints::ConstantConstraint::score(const class core::scoring::func::XYZ_Func &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

score_type(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.core.scoring.ScoreType

Returns the ScoreType that this Constraint object will use.

C++: core::scoring::constraints::Constraint::score_type() const –> const enum core::scoring::ScoreType &

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_derivatives(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_scoring(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::ConstantConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::constraints::ConstantConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint, : pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int, : float) int

output violation of constraint (none!)

C++: core::scoring::constraints::ConstantConstraint::show_violations(std::ostream &, const class core::pose::Pose &, unsigned long, double) const –> unsigned long

steal_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose) None

take coordinates, distances, angles, etc from given pose

C++: core::scoring::constraints::Constraint::steal_def(const class core::pose::Pose &) –> void

to_string(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) str
Convenience function, returns the results of show() as a string.

Not to be overriden by derived classes.

C++: core::scoring::constraints::Constraint::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint) str

C++: core::scoring::constraints::ConstantConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.Constraint

Bases: pybind11_builtins.pybind11_object

Actually a restraint, like a virtual rubber band between a pair of atoms.

All Constraints are expected to be immutable once created, meaning their internal data (state) should not change over their lifetime. This allows Constraints to be shared between copies of Poses (e.g. in Monte Carlo), and is important for both speed (with thousands of constraints) and correctness.

To “change” a constraint, remove the old one and add a new and different one. The steal() methods have been removed because it is incompatible with the idea of immutable constraints.

atom(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, index: int) pyrosetta.rosetta.core.id.AtomID

Returns the AtomID referred to by index.

Note that this function isn’t actually used by the constraint scoring machenery. If you’re calling it on a generic Constraint (as opposed to specifically on a derived class) you’re probably doing something wrong.

C++: core::scoring::constraints::Constraint::atom(const unsigned long) const –> const class core::id::AtomID &

choose_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, : numeric::random::RandomGenerator) int

C++: core::scoring::constraints::Constraint::choose_effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &, class numeric::random::RandomGenerator &) –> unsigned long

clone(*args, **kwargs)

Overloaded function.

  1. clone(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

Copies the data from this %Constraint into a new object and returns

an OP to the new object. Intended to be implemented by derived classes and used by pose.add_constraint. This function must return a deep copy of itself – meaning that if this %Constraint holds pointers to other %Constraints that it must invoke clone on those %Constraints as well. If the %Constraint holds a FuncOP, then the Func should also be cloned.

C++: core::scoring::constraints::Constraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

  1. clone(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::Func) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

Clone the constraint, but where a new Func object is to be used instead.

C++: core::scoring::constraints::Constraint::clone(class std::shared_ptr<class core::scoring::func::Func>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)

Overloaded function.

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float

return the raw “distance” before that distance is handed to the FUNC object

  • If such a distance doesn’t make sense for this constraint, just return 0

C++: core::scoring::constraints::Constraint::dist(const class core::scoring::func::XYZ_Func &) const –> double

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose) -> float

return the raw “distance” before that distance is handed to the FUNC object

  • If such a distance doesn’t make sense for this constraint, just return 0

C++: core::scoring::constraints::Constraint::dist(const class core::pose::Pose &) const –> double

effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) int

C++: core::scoring::constraints::Constraint::effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &) const –> unsigned long

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, atom: pyrosetta.rosetta.core.id.AtomID, xyz_func: core::scoring::func::XYZ_Func, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t, weights: pyrosetta.rosetta.core.scoring.EMapVector) None
Fill the f1 and f2 vectors, necessary for considering the

derivative this constraint during minimization. (someone please reference Bill Wedermeyer’s paper here, as I’m in an airport and can’t fill it in myself!)

C++: core::scoring::constraints::Constraint::fill_f1_f2(const class core::id::AtomID &, const class core::scoring::func::XYZ_Func &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const class core::scoring::EMapVector &) const –> void

get_func(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) core::scoring::func::Func

Returns the func::Func object associated with this Constraint object.

C++: core::scoring::constraints::Constraint::get_func() const –> const class core::scoring::func::Func &

natoms(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) int
Returns the number of atoms involved in defining this constraint.

If the constraint doesn’t depend on particular atoms (e.g. a residue type constraint) this function can return zero

Note that this function isn’t actually used by the constraint scoring machenery. If you’re calling it on a generic Constraint (as opposed to specifically on a derived class) you’re probably doing something wrong.

C++: core::scoring::constraints::Constraint::natoms() const –> unsigned long

read_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose) None
This method is totally redundant with read_def YAY

DON’T USE THIS ONE.. Most Constraint classes have not overloaded this one, but read_def ! OL

C++: core::scoring::constraints::Constraint::read_constraint(std::istream &, const class core::pose::Pose &) –> void

read_data(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream) None
initialize this Constraint from the given std::istream. It’s amazing

that there are three functions for doing this inside of Constraint.hh. SO WHAT IS THIS SUPPOSED TO DO ? not overloaded by e.g., AtomPairConstraint or CoordinateConstraint,

C++: core::scoring::constraints::Constraint::read_data(std::istream &) –> void

read_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose, : core::scoring::func::FuncFactory) None
Reads the definition of a Constraint from the given std::istream,

using the given Pose, and the given func::FuncFactory. This method is intended to be overridden by derived classes if they’d like to use the ConstraintIO machinery.

C++: core::scoring::constraints::Constraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint
apply a resid remapping to this constraint, returns the remapped

constraint Does this return an owning pointer to this constraint or a copy? Documentation would be nice.

C++: core::scoring::constraints::Constraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, map: pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint
Copies the data from this Constraint into a new object and returns

an OP atoms are mapped to atoms with the same name in dest pose ( e.g. for switch from centroid to fullatom ) if a sequence_mapping is present it is used to map residue numbers .. NULL = identity mapping to the new object. Intended to be implemented by derived classes.

C++: core::scoring::constraints::Constraint::remapped_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

residues(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the pose numbers of the residues involved in this constraint, in no particular order.

Used in determining one-body/two-body/multi-body status. For historical reasons, the default uses a simple protocol based on natoms()/atom() - feel free to reimplement more efficiently.

C++: core::scoring::constraints::Constraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) bool
Determine if the calling class has the same type as the

input class, using dynamic casts. This is important in ensuring that two constraints are equal: both this and other must check that the other is the same as it. This is not an optional method and every class should implement it, regaurdless of whether a parent class implements it.

C++: core::scoring::constraints::Constraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)

Overloaded function.

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, xyz_func: core::scoring::func::XYZ_Func, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

Calculates a score for this constraint using XYZ_Func, and puts

the UNWEIGHTED score into emap. Although the current set of weights currently is provided, Constraint objects should put unweighted scores into emap because the ScoreFunction will do the weighting itself.

C++: core::scoring::constraints::Constraint::score(const class core::scoring::func::XYZ_Func &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float

Returns the unweighted score of this constraint computed over the given pose.

C++: core::scoring::constraints::Constraint::score(const class core::pose::Pose &) const –> double

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float

Returns the weighted score of this constraint computed over the given pose.

C++: core::scoring::constraints::Constraint::score(const class core::pose::Pose &, const class core::scoring::EMapVector &) const –> double

score_type(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.core.scoring.ScoreType

Returns the ScoreType that this Constraint object will use.

C++: core::scoring::constraints::Constraint::score_type() const –> const enum core::scoring::ScoreType &

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_derivatives(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_scoring(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.ostream) None
This method is intended to show the value of the Constraint function

evaluated over some reasonable range of values. For example, a constraint between pairs of atoms might show the values of the Constraint function between 4 and 12 angstroms.

C++: core::scoring::constraints::Constraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose) None
Prints the definition of a Constraint to the given std::ostream,

using the given Pose, and the given func::FuncFactory. This method is intended to be overridden by derived classes if they’d like to use the ConstraintIO machinery. It’s also not clear why this method takes a Pose, other than to be symmetric with read_def.

C++: core::scoring::constraints::Constraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int, threshold: float) -> int

Prints the violations of this constraint to the given

std::ostream. What are violations? It’s not defined, and it depends on the constraint and the function! also - wtf is threshold? it was defined as a Size in CoordinateConstraint, I don’t know which definition is the right one. Documentation would be nice …

C++: core::scoring::constraints::Constraint::show_violations(std::ostream &, const class core::pose::Pose &, unsigned long, double) const –> unsigned long

steal_def(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.pose.Pose) None

take coordinates, distances, angles, etc from given pose

C++: core::scoring::constraints::Constraint::steal_def(const class core::pose::Pose &) –> void

to_string(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) str
Convenience function, returns the results of show() as a string.

Not to be overriden by derived classes.

C++: core::scoring::constraints::Constraint::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) str
Returns a unique string identified for this constraint. Used in several

places, including the ConstraintIO class.

C++: core::scoring::constraints::Constraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator

Bases: pybind11_builtins.pybind11_object

Abstract base class for a Mover factory; the Creator class is responsible for creating a particular mover class.

assign(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator

C++: core::scoring::constraints::ConstraintCreator::operator=(const class core::scoring::constraints::ConstraintCreator &) –> class core::scoring::constraints::ConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::ConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator) str

C++: core::scoring::constraints::ConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge

Bases: pyrosetta.rosetta.utility.graph.Edge

angle_constraint_energy(*args, **kwargs)

Overloaded function.

  1. angle_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::angle_constraint_energy(double) –> void

  1. angle_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge) -> float

C++: core::scoring::constraints::ConstraintEdge::angle_constraint_energy() const –> double

atom_pair_constraint_energy(*args, **kwargs)

Overloaded function.

  1. atom_pair_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::atom_pair_constraint_energy(double) –> void

  1. atom_pair_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge) -> float

C++: core::scoring::constraints::ConstraintEdge::atom_pair_constraint_energy() const –> double

backbone_stub_constraint_energy(*args, **kwargs)

Overloaded function.

  1. backbone_stub_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::backbone_stub_constraint_energy(double) –> void

  1. backbone_stub_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge) -> float

C++: core::scoring::constraints::ConstraintEdge::backbone_stub_constraint_energy() const –> double

backbone_stub_linear_constraint_energy(*args, **kwargs)

Overloaded function.

  1. backbone_stub_linear_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::backbone_stub_linear_constraint_energy(double) –> void

  1. backbone_stub_linear_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge) -> float

C++: core::scoring::constraints::ConstraintEdge::backbone_stub_linear_constraint_energy() const –> double

base_pair_constraint_energy(*args, **kwargs)

Overloaded function.

  1. base_pair_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::base_pair_constraint_energy(double) –> void

  1. base_pair_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge) -> float

C++: core::scoring::constraints::ConstraintEdge::base_pair_constraint_energy() const –> double

bond_geometry_energy(*args, **kwargs)

Overloaded function.

  1. bond_geometry_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::bond_geometry_energy(double) –> void

  1. bond_geometry_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge) -> float

C++: core::scoring::constraints::ConstraintEdge::bond_geometry_energy() const –> double

coordinate_constraint_energy(*args, **kwargs)

Overloaded function.

  1. coordinate_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::coordinate_constraint_energy(double) –> void

  1. coordinate_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge) -> float

C++: core::scoring::constraints::ConstraintEdge::coordinate_constraint_energy() const –> double

copy_from(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, source: pyrosetta.rosetta.utility.graph.Edge) None

C++: core::scoring::constraints::ConstraintEdge::copy_from(const class utility::graph::Edge *) –> void

count_dynamic_memory(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge) int

C++: core::scoring::constraints::ConstraintEdge::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge) int

C++: core::scoring::constraints::ConstraintEdge::count_static_memory() const –> unsigned long

dihedral_constraint_energy(*args, **kwargs)

Overloaded function.

  1. dihedral_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::dihedral_constraint_energy(double) –> void

  1. dihedral_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge) -> float

C++: core::scoring::constraints::ConstraintEdge::dihedral_constraint_energy() const –> double

energy_computed(*args, **kwargs)

Overloaded function.

  1. energy_computed(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, setting: bool) -> None

C++: core::scoring::constraints::ConstraintEdge::energy_computed(bool) –> void

  1. energy_computed(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge) -> bool

C++: core::scoring::constraints::ConstraintEdge::energy_computed() const –> bool

get_first_node_ind(self: pyrosetta.rosetta.utility.graph.Edge) int

returns the index of the lower node

C++: utility::graph::Edge::get_first_node_ind() const –> unsigned long

get_other_ind(self: pyrosetta.rosetta.utility.graph.Edge, node_index: int) int
returns the index of the one node given the index of the other.

node_index must be one of the two nodes that this edge is incident upon.

C++: utility::graph::Edge::get_other_ind(unsigned long) const –> unsigned long

get_other_node(self: pyrosetta.rosetta.utility.graph.Edge, node_index: int) pyrosetta.rosetta.utility.graph.Node
returns a non-const pointer to one node given the index of the other.

node_index must be one of the two nodes that this edge is incident upon.

C++: utility::graph::Edge::get_other_node(unsigned long) –> class utility::graph::Node *

get_second_node_ind(self: pyrosetta.rosetta.utility.graph.Edge) int

returns the index of the upper node

C++: utility::graph::Edge::get_second_node_ind() const –> unsigned long

is_loop(self: pyrosetta.rosetta.utility.graph.Edge) bool

Is this edge a loop? In Pseudographs, loop edges are incident twice on a single vertex.

C++: utility::graph::Edge::is_loop() const –> bool

metalbinding_constraint_energy(*args, **kwargs)

Overloaded function.

  1. metalbinding_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::metalbinding_constraint_energy(double) –> void

  1. metalbinding_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge) -> float

C++: core::scoring::constraints::ConstraintEdge::metalbinding_constraint_energy() const –> double

res_type_linking_constraint_energy(*args, **kwargs)

Overloaded function.

  1. res_type_linking_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::res_type_linking_constraint_energy(double) –> void

  1. res_type_linking_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge) -> float

C++: core::scoring::constraints::ConstraintEdge::res_type_linking_constraint_energy() const –> double

rna_bond_geometry_energy(*args, **kwargs)

Overloaded function.

  1. rna_bond_geometry_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::rna_bond_geometry_energy(double) –> void

  1. rna_bond_geometry_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge) -> float

C++: core::scoring::constraints::ConstraintEdge::rna_bond_geometry_energy() const –> double

same_edge(self: pyrosetta.rosetta.utility.graph.Edge, node1: int, node2: int) bool
Is this the same edge as another edge (node1,node2)? Note:

this graph does not work for multi-graphs. Edges must be unique.

C++: utility::graph::Edge::same_edge(unsigned long, unsigned long) const –> bool

set_pos_in_owners_list(self: pyrosetta.rosetta.utility.graph.Edge, edge_iterator: pyrosetta.rosetta.utility.graph.EdgeListIterator) None
called only by class Graph, this function gives the Edge the data it needs

to later delete itself from its owner’s edge list in constant time.

C++: utility::graph::Edge::set_pos_in_owners_list(class utility::graph::EdgeListIterator) –> void

class pyrosetta.rosetta.core.scoring.constraints.ConstraintFactory

Bases: pyrosetta.rosetta.utility.SingletonBase_core_scoring_constraints_ConstraintFactory_t

factory_register(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintFactory, creator: pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator) None

C++: core::scoring::constraints::ConstraintFactory::factory_register(class std::shared_ptr<const class core::scoring::constraints::ConstraintCreator>) –> void

get_creator(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintFactory, type_name: str) pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator

C++: core::scoring::constraints::ConstraintFactory::get_creator(const std::string &) –> class std::shared_ptr<const class core::scoring::constraints::ConstraintCreator>

get_cst_names(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintFactory) pyrosetta.rosetta.utility.vector1_std_string

C++: core::scoring::constraints::ConstraintFactory::get_cst_names() const –> class utility::vector1<std::string, class std::allocator<std::string > >

static get_instance() core::scoring::constraints::ConstraintFactory

C++: utility::SingletonBase<core::scoring::constraints::ConstraintFactory>::get_instance() –> class core::scoring::constraints::ConstraintFactory *

newConstraint(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintFactory, type_name: str) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::ConstraintFactory::newConstraint(const std::string &) –> class std::shared_ptr<class core::scoring::constraints::Constraint>

replace_creator(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintFactory, creator: pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator) None
Replace the load-time ConstraintCreator with another creator.

WARNING WARNING WARNING THREAD UNSAFE!!! DO NOT USE THIS!!!

C++: core::scoring::constraints::ConstraintFactory::replace_creator(class std::shared_ptr<const class core::scoring::constraints::ConstraintCreator>) –> void

class pyrosetta.rosetta.core.scoring.constraints.ConstraintGraph

Bases: pyrosetta.rosetta.utility.graph.Graph

add_edge(*args, **kwargs)

Overloaded function.

  1. add_edge(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) -> pyrosetta.rosetta.utility.graph.Edge

add an edge between two vertices. Invokes “create_edge” from the derived class.

Returns a pointer to the edge after its been added, allowing the calling function to immediately set data for this edge.

C++: utility::graph::Graph::add_edge(unsigned long, unsigned long) –> class utility::graph::Edge *

  1. add_edge(self: pyrosetta.rosetta.utility.graph.Graph, example_edge: pyrosetta.rosetta.utility.graph.Edge) -> pyrosetta.rosetta.utility.graph.Edge

add an edge to this graph copying the data from an edge in another graph.

Returns a pointer to the edge after its been added, allowing the calling function to immediately set data for this edge.

C++: utility::graph::Graph::add_edge(const class utility::graph::Edge *) –> class utility::graph::Edge *

all_pairs_shortest_paths(self: pyrosetta.rosetta.utility.graph.Graph) pyrosetta.rosetta.ObjexxFCL.FArray2D_int_t
O(V^3). Computes all pairs shortest paths using Warshall’s algorithm

and writes all the path distances to the two-dimensional table.

C++: utility::graph::Graph::all_pairs_shortest_paths() const –> class ObjexxFCL::FArray2D<int>

assign(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintGraph, source: pyrosetta.rosetta.core.scoring.constraints.ConstraintGraph) pyrosetta.rosetta.core.scoring.constraints.ConstraintGraph

C++: core::scoring::constraints::ConstraintGraph::operator=(const class core::scoring::constraints::ConstraintGraph &) –> class core::scoring::constraints::ConstraintGraph &

const_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Graph) pyrosetta.rosetta.utility.graph.EdgeListConstIterator
returns a const iterator to the beginning of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::const_edge_list_begin() const –> class utility::graph::EdgeListConstIterator

const_edge_list_end(self: pyrosetta.rosetta.utility.graph.Graph) pyrosetta.rosetta.utility.graph.EdgeListConstIterator
returns a const iterator to the end of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::const_edge_list_end() const –> class utility::graph::EdgeListConstIterator

copy_connectivity(self: pyrosetta.rosetta.utility.graph.Graph, source: pyrosetta.rosetta.utility.graph.Graph) None
copy the edge connectivity from a source graph with a potentially

unknown type.

C++: utility::graph::Graph::copy_connectivity(const class utility::graph::Graph &) –> void

delete_edge(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintGraph, edge: pyrosetta.rosetta.utility.graph.Edge) None

C++: core::scoring::constraints::ConstraintGraph::delete_edge(class utility::graph::Edge *) –> void

drop_all_edges(self: pyrosetta.rosetta.utility.graph.Graph) None

delete all the edges present in the graph

C++: utility::graph::Graph::drop_all_edges() –> void

drop_all_edges_for_node(self: pyrosetta.rosetta.utility.graph.Graph, node: int) None

delete all the edges for a single vertex in the graph

C++: utility::graph::Graph::drop_all_edges_for_node(unsigned long) –> void

edge_list_begin(self: pyrosetta.rosetta.utility.graph.Graph) pyrosetta.rosetta.utility.graph.EdgeListIterator
returns a non-const iterator to the beginning of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::edge_list_begin() –> class utility::graph::EdgeListIterator

edge_list_end(self: pyrosetta.rosetta.utility.graph.Graph) pyrosetta.rosetta.utility.graph.EdgeListIterator
returns a non-const iterator to the end of the (unordered) edge list for the graph.

this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::edge_list_end() –> class utility::graph::EdgeListIterator

find_edge(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) pyrosetta.rosetta.utility.graph.Edge
returns a pointer to the edge connecting nodes node1 and node2, if that edge exists

in the graph, o.w. returns 0. Focuses the graph on this edge for fast subsequent retrieval.

C++: utility::graph::Graph::find_edge(unsigned long, unsigned long) –> class utility::graph::Edge *

focused_edge(self: pyrosetta.rosetta.utility.graph.Graph) pyrosetta.rosetta.utility.graph.Edge

returns a pointer to the focused edge

C++: utility::graph::Graph::focused_edge() –> class utility::graph::Edge *

getTotalMemoryUsage(self: pyrosetta.rosetta.utility.graph.Graph) int
returns a count of all the memory used by every vertex and edge in a graph

by invoking the polymorphic count_static_memory and count_dynamic_memory of each (possibly derived) node and edge object as well as for the (possibly derived) graph class.

C++: utility::graph::Graph::getTotalMemoryUsage() const –> unsigned long

get_edge_exists(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) bool

is an edge already present in the graph? O(V) worst case. O(1) iff all vertices have O(1) edges

C++: utility::graph::Graph::get_edge_exists(unsigned long, unsigned long) const –> bool

get_node(self: pyrosetta.rosetta.utility.graph.Graph, index: int) pyrosetta.rosetta.utility.graph.Node

C++: utility::graph::Graph::get_node(unsigned long) –> class utility::graph::Node *

get_self_ptr(self: pyrosetta.rosetta.utility.graph.Graph) pyrosetta.rosetta.utility.graph.Graph

C++: utility::graph::Graph::get_self_ptr() –> class std::shared_ptr<class utility::graph::Graph>

num_edges(self: pyrosetta.rosetta.utility.graph.Graph) int

C++: utility::graph::Graph::num_edges() const –> unsigned long

num_nodes(self: pyrosetta.rosetta.utility.graph.Graph) int

the number of nodes in the graph

C++: utility::graph::Graph::num_nodes() const –> unsigned long

output_connectivity(self: pyrosetta.rosetta.utility.graph.Graph, os: pyrosetta.rosetta.std.ostream) None

send an edge list to the stream os.

C++: utility::graph::Graph::output_connectivity(std::ostream &) const –> void

output_dimacs(self: pyrosetta.rosetta.utility.graph.Graph, os: pyrosetta.rosetta.std.ostream) None

describe this graph in dimacs form to the stream os.

C++: utility::graph::Graph::output_dimacs(std::ostream &) const –> void

print_vertices(self: pyrosetta.rosetta.utility.graph.Graph) None

send summary information to the screen for all vertices in the graph

C++: utility::graph::Graph::print_vertices() const –> void

set_num_nodes(self: pyrosetta.rosetta.utility.graph.Graph, num_nodes: int) None

set the number of nodes in the graph – deletes any existing edges in the graph

C++: utility::graph::Graph::set_num_nodes(unsigned long) –> void

class pyrosetta.rosetta.core.scoring.constraints.ConstraintIO

Bases: pyrosetta.rosetta.utility.SingletonBase_core_scoring_constraints_ConstraintIO_t

static get_cst_factory() pyrosetta.rosetta.core.scoring.constraints.ConstraintFactory

C++: core::scoring::constraints::ConstraintIO::get_cst_factory() –> class core::scoring::constraints::ConstraintFactory &

static get_func_factory() pyrosetta.rosetta.core.scoring.func.FuncFactory

C++: core::scoring::constraints::ConstraintIO::get_func_factory() –> class core::scoring::func::FuncFactory &

static get_instance() core::scoring::constraints::ConstraintIO

C++: utility::SingletonBase<core::scoring::constraints::ConstraintIO>::get_instance() –> class core::scoring::constraints::ConstraintIO *

static parse_atom_pair_constraint(*args, **kwargs)

Overloaded function.

  1. parse_atom_pair_constraint(data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

  2. parse_atom_pair_constraint(data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, force_pdb_info_mapping: bool) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::ConstraintIO::parse_atom_pair_constraint(std::istream &, class core::pose::Pose, const bool) –> class std::shared_ptr<class core::scoring::constraints::Constraint>

static parse_coordinate_constraint(*args, **kwargs)

Overloaded function.

  1. parse_coordinate_constraint(data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

  2. parse_coordinate_constraint(data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, force_pdb_info_mapping: bool) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::ConstraintIO::parse_coordinate_constraint(std::istream &, class core::pose::Pose, const bool) –> class std::shared_ptr<class core::scoring::constraints::Constraint>

static parse_residue(*args, **kwargs)

Overloaded function.

  1. parse_residue(pose: pyrosetta.rosetta.core.pose.Pose, residue_string: str, residue_num: int) -> None

  2. parse_residue(pose: pyrosetta.rosetta.core.pose.Pose, residue_string: str, residue_num: int, force_pdb_info_mapping: bool) -> None

C++: core::scoring::constraints::ConstraintIO::parse_residue(const class core::pose::Pose &, const std::string &, unsigned long &, const bool) –> void

  1. parse_residue(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int) -> int

  2. parse_residue(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int, chain: str) -> int

  3. parse_residue(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int, chain: str, force_pdb_info_numbering: bool) -> int

a value of 0 for the chain means to ignore PDBInfo settings,

and treat the resnum as Rosetta/Pose numbering.

C++: core::scoring::constraints::ConstraintIO::parse_residue(const class core::pose::Pose &, const int, const char, const bool) –> unsigned long

static read_constraints(*args, **kwargs)

Overloaded function.

  1. read_constraints(filename: str, cst_set: core::scoring::constraints::ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::constraints::ConstraintSet

  2. read_constraints(filename: str, cst_set: core::scoring::constraints::ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose, force_pdb_info_mapping: bool) -> core::scoring::constraints::ConstraintSet

C++: core::scoring::constraints::ConstraintIO::read_constraints(const std::string &, class std::shared_ptr<class core::scoring::constraints::ConstraintSet>, const class core::pose::Pose &, const bool) –> class std::shared_ptr<class core::scoring::constraints::ConstraintSet>

  1. read_constraints(data: pyrosetta.rosetta.std.istream, cst_set: core::scoring::constraints::ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::constraints::ConstraintSet

  2. read_constraints(data: pyrosetta.rosetta.std.istream, cst_set: core::scoring::constraints::ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose, force_pdb_info_mapping: bool) -> core::scoring::constraints::ConstraintSet

C++: core::scoring::constraints::ConstraintIO::read_constraints(std::istream &, class std::shared_ptr<class core::scoring::constraints::ConstraintSet>, const class core::pose::Pose &, const bool) –> class std::shared_ptr<class core::scoring::constraints::ConstraintSet>

static read_constraints_new(*args, **kwargs)

Overloaded function.

  1. read_constraints_new(fname: str, cset: core::scoring::constraints::ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::constraints::ConstraintSet

  2. read_constraints_new(fname: str, cset: core::scoring::constraints::ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose, force_pdb_info_mapping: bool) -> core::scoring::constraints::ConstraintSet

C++: core::scoring::constraints::ConstraintIO::read_constraints_new(const std::string &, class std::shared_ptr<class core::scoring::constraints::ConstraintSet>, const class core::pose::Pose &, const bool) –> class std::shared_ptr<class core::scoring::constraints::ConstraintSet>

  1. read_constraints_new(data: pyrosetta.rosetta.std.istream, cset: core::scoring::constraints::ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::constraints::ConstraintSet

  2. read_constraints_new(data: pyrosetta.rosetta.std.istream, cset: core::scoring::constraints::ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose, force_pdb_info_mapping: bool) -> core::scoring::constraints::ConstraintSet

C++: core::scoring::constraints::ConstraintIO::read_constraints_new(std::istream &, class std::shared_ptr<class core::scoring::constraints::ConstraintSet>, const class core::pose::Pose &, const bool) –> class std::shared_ptr<class core::scoring::constraints::ConstraintSet>

static read_individual_constraint_new(*args, **kwargs)

Overloaded function.

  1. read_individual_constraint_new(data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: pyrosetta.rosetta.core.scoring.func.FuncFactory) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

  2. read_individual_constraint_new(data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: pyrosetta.rosetta.core.scoring.func.FuncFactory, force_pdb_info_mapping: bool) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

read one individual constraint defined.

C++: core::scoring::constraints::ConstraintIO::read_individual_constraint_new(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &, const bool) –> class std::shared_ptr<class core::scoring::constraints::Constraint>

  1. read_individual_constraint_new(data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: pyrosetta.rosetta.core.scoring.func.FuncFactory, type: str) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

  2. read_individual_constraint_new(data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: pyrosetta.rosetta.core.scoring.func.FuncFactory, type: str, force_pdb_info_mapping: bool) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

read one individual constraint defined.

C++: core::scoring::constraints::ConstraintIO::read_individual_constraint_new(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &, std::string, const bool) –> class std::shared_ptr<class core::scoring::constraints::Constraint>

static write_constraints(*args, **kwargs)

Overloaded function.

  1. write_constraints(: pyrosetta.rosetta.std.ostream, cst_set: core::scoring::constraints::ConstraintSet, : pyrosetta.rosetta.core.pose.Pose) -> None

C++: core::scoring::constraints::ConstraintIO::write_constraints(std::ostream &, const class core::scoring::constraints::ConstraintSet &, const class core::pose::Pose &) –> void

  1. write_constraints(filename: str, cst_set: core::scoring::constraints::ConstraintSet, : pyrosetta.rosetta.core.pose.Pose) -> None

C++: core::scoring::constraints::ConstraintIO::write_constraints(const std::string &, const class core::scoring::constraints::ConstraintSet &, const class core::pose::Pose &) –> void

class pyrosetta.rosetta.core.scoring.constraints.ConstraintNode

Bases: pyrosetta.rosetta.utility.graph.Node

add_edge(self: pyrosetta.rosetta.utility.graph.Node, edge_ptr: utility::graph::Edge, : pyrosetta.rosetta.utility.graph.EdgeListIterator) None
adds edge pointer to edge list; returns an iterator to the new

list element

C++: utility::graph::Node::add_edge(class utility::graph::Edge *, class utility::graph::EdgeListIterator &) –> void

const_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) pyrosetta.rosetta.utility.graph.EdgeListConstIterator

returns a const iterator to the beginning of its edge list

C++: utility::graph::Node::const_edge_list_begin() const –> class utility::graph::EdgeListConstIterator

const_edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) pyrosetta.rosetta.utility.graph.EdgeListConstIterator

returns a const iterator to the end of its edge list

C++: utility::graph::Node::const_edge_list_end() const –> class utility::graph::EdgeListConstIterator

const_lower_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) pyrosetta.rosetta.utility.graph.EdgeListConstIterator

returns a const iterator to the beginning of its lower-edge list

C++: utility::graph::Node::const_lower_edge_list_begin() const –> class utility::graph::EdgeListConstIterator

const_lower_edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) pyrosetta.rosetta.utility.graph.EdgeListConstIterator

returns a const iterator to the end of its lower-edge list

C++: utility::graph::Node::const_lower_edge_list_end() const –> class utility::graph::EdgeListConstIterator

const_upper_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) pyrosetta.rosetta.utility.graph.EdgeListConstIterator

returns a const iterator to the beginning of its upper-edge list

C++: utility::graph::Node::const_upper_edge_list_begin() const –> class utility::graph::EdgeListConstIterator

const_upper_edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) pyrosetta.rosetta.utility.graph.EdgeListConstIterator

returns a const iterator to the end of its upper-edge list

C++: utility::graph::Node::const_upper_edge_list_end() const –> class utility::graph::EdgeListConstIterator

copy_from(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintNode, source: pyrosetta.rosetta.utility.graph.Node) None

C++: core::scoring::constraints::ConstraintNode::copy_from(const class utility::graph::Node *) –> void

count_dynamic_memory(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintNode) int

C++: core::scoring::constraints::ConstraintNode::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintNode) int

C++: core::scoring::constraints::ConstraintNode::count_static_memory() const –> unsigned long

drop_all_edges(self: pyrosetta.rosetta.utility.graph.Node) None

deletes all edges incident upon this node

C++: utility::graph::Node::drop_all_edges() –> void

drop_edge(self: pyrosetta.rosetta.utility.graph.Node, edge_iterator: pyrosetta.rosetta.utility.graph.EdgeListIterator) None

removes an edge iterator from the node’s edge list. Only called by Edge class.

C++: utility::graph::Node::drop_edge(class utility::graph::EdgeListIterator) –> void

edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) pyrosetta.rosetta.utility.graph.EdgeListIterator

returns a non-const iterator to the beginning of its edge list

C++: utility::graph::Node::edge_list_begin() –> class utility::graph::EdgeListIterator

edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) pyrosetta.rosetta.utility.graph.EdgeListIterator

returns a non-const iterator to the end of its edge list

C++: utility::graph::Node::edge_list_end() –> class utility::graph::EdgeListIterator

find_edge(self: pyrosetta.rosetta.utility.graph.Node, other_node_index: int) utility::graph::Edge

C++: utility::graph::Node::find_edge(unsigned long) –> class utility::graph::Edge *

get_node_index(self: pyrosetta.rosetta.utility.graph.Node) int

the index for this node

C++: utility::graph::Node::get_node_index() const –> unsigned long

get_num_edges_to_larger_indexed_nodes(self: pyrosetta.rosetta.utility.graph.Node) int
the number of upper neighbors – which “self” neighborness is counted if a loop edge

is present

C++: utility::graph::Node::get_num_edges_to_larger_indexed_nodes() const –> unsigned long

get_num_edges_to_smaller_indexed_nodes(self: pyrosetta.rosetta.utility.graph.Node) int

the number of lower neighbors

C++: utility::graph::Node::get_num_edges_to_smaller_indexed_nodes() const –> unsigned long

loop_incident(self: pyrosetta.rosetta.utility.graph.Node) bool

NOTE TO SELF: remove loop support

C++: utility::graph::Node::loop_incident() const –> bool

lower_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) pyrosetta.rosetta.utility.graph.EdgeListIterator

returns a non-const iterator to the beginning of its lower-edge list

C++: utility::graph::Node::lower_edge_list_begin() –> class utility::graph::EdgeListIterator

lower_edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) pyrosetta.rosetta.utility.graph.EdgeListIterator

returns a non-const iterator to the end of its lower-edge list

C++: utility::graph::Node::lower_edge_list_end() –> class utility::graph::EdgeListIterator

num_edges(self: pyrosetta.rosetta.utility.graph.Node) int

the number of edges incident on this node, which may include a loop edge

C++: utility::graph::Node::num_edges() const –> unsigned long

num_neighbors_counting_self(self: pyrosetta.rosetta.utility.graph.Node) int

the number of neighbors counting “self” as a neighbor.

C++: utility::graph::Node::num_neighbors_counting_self() const –> unsigned long

num_neighbors_counting_self_static(self: pyrosetta.rosetta.utility.graph.Node) int
the number of neighbors counting “self” as neighbor. Defaults to

num_neighbors_counting_self() but can be set to other values as well. Useful in calculation of symmetrical structures.

C++: utility::graph::Node::num_neighbors_counting_self_static() const –> unsigned long

print(self: pyrosetta.rosetta.utility.graph.Node) None

send summaray data about this node to the screen

C++: utility::graph::Node::print() const –> void

set_num_neighbors_counting_self_static(self: pyrosetta.rosetta.utility.graph.Node, neighbor: int) None
manually change the number of neighbors for a Node. Used

for symmetry scoring

C++: utility::graph::Node::set_num_neighbors_counting_self_static(unsigned long) –> void

upper_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) pyrosetta.rosetta.utility.graph.EdgeListIterator

returns a non-const iterator to the beginning of its upper-edge list

C++: utility::graph::Node::upper_edge_list_begin() –> class utility::graph::EdgeListIterator

upper_edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) pyrosetta.rosetta.utility.graph.EdgeListIterator

returns a non-const iterator to the end of its upper-edge list

C++: utility::graph::Node::upper_edge_list_end() –> class utility::graph::EdgeListIterator

class pyrosetta.rosetta.core.scoring.constraints.ConstraintSet

Bases: pybind11_builtins.pybind11_object

add_constraint(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, cst: pyrosetta.rosetta.core.scoring.constraints.Constraint) None

C++: core::scoring::constraints::ConstraintSet::add_constraint(class std::shared_ptr<const class core::scoring::constraints::Constraint>) –> void

add_constraints(*args, **kwargs)

Overloaded function.

  1. add_constraints(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, cst_list: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) -> None

C++: core::scoring::constraints::ConstraintSet::add_constraints(class utility::vector1<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > >) –> void

  1. add_constraints(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, cst_set: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) -> None

add another constraint set to this constraint set

C++: core::scoring::constraints::ConstraintSet::add_constraints(const class std::shared_ptr<const class core::scoring::constraints::ConstraintSet>) –> void

add_dof_constraint(*args, **kwargs)

Overloaded function.

  1. add_dof_constraint(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, id: pyrosetta.rosetta.core.id.DOF_ID, func: pyrosetta.rosetta.core.scoring.func.Func) -> None

  2. add_dof_constraint(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, id: pyrosetta.rosetta.core.id.DOF_ID, func: pyrosetta.rosetta.core.scoring.func.Func, t: pyrosetta.rosetta.core.scoring.ScoreType) -> None

Note – still hacky. Will not be included in packing, just scoring

and minimization

C++: core::scoring::constraints::ConstraintSet::add_dof_constraint(const class core::id::DOF_ID &, class std::shared_ptr<class core::scoring::func::Func>, const enum core::scoring::ScoreType &) –> void

assign(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, rhs: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) pyrosetta.rosetta.core.scoring.constraints.ConstraintSet
Assignment operator – requires that “same_type_as_me” has already

been called. This performs a shallow copy of all of the constraints held in the ConstraintSet, efficiently avoiding copy operations on ResidueConstraint objects that are already identical.

C++: core::scoring::constraints::ConstraintSet::operator=(const class core::scoring::constraints::ConstraintSet &) –> class core::scoring::constraints::ConstraintSet &

attach_to_conformation(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, conformation: pyrosetta.rosetta.std.weak_ptr_const_core_conformation_Conformation_t) None

C++: core::scoring::constraints::ConstraintSet::attach_to_conformation(class std::weak_ptr<const class core::conformation::Conformation>) –> void

clear(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) None

C++: core::scoring::constraints::ConstraintSet::clear() –> void

clear_sequence_constraints(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) None

Discard any and all sequence constraints in the sequence_constraints_ list.

C++: core::scoring::constraints::ConstraintSet::clear_sequence_constraints() –> void

clone(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) pyrosetta.rosetta.core.scoring.constraints.ConstraintSet
Clone operator – performs a shallow copy of the contained

constraints.

C++: core::scoring::constraints::ConstraintSet::clone() const –> class std::shared_ptr<class core::scoring::constraints::ConstraintSet>

deprecated_eval_atom_derivative(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, atom_id: pyrosetta.rosetta.core.id.AtomID, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.ScoreFunction, weights: pyrosetta.rosetta.core.scoring.EMapVector, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) None
Switching over to a pairwise decomposable eval-atom-deriv system for

RTMin means deprecating the old “evaluate an atom’s derivative wrt the entire structure” This function is preserved (for now) for use by the RNA_TorsionEnergy

C++: core::scoring::constraints::ConstraintSet::deprecated_eval_atom_derivative(const class core::id::AtomID &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::scoring::EMapVector &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

detach_from_conformation(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) None

C++: core::scoring::constraints::ConstraintSet::detach_from_conformation() –> void

detached_clone(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) pyrosetta.rosetta.core.scoring.constraints.ConstraintSet
Clone operator – performs a shallow copy of the contained

constraints.

C++: core::scoring::constraints::ConstraintSet::detached_clone() const –> class std::shared_ptr<class core::scoring::constraints::ConstraintSet>

detached_copy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, src: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) None
Perform a deep copy of the source %ConstraintSet into this %ConstraintSet

so that the two do not share any data in common – and can thus this %constraintSet can be safely handed to another thread; this function relies on the Constraint class’s clone() method, which is required to create a deep copy of itself.

C++: core::scoring::constraints::ConstraintSet::detached_copy(const class core::scoring::constraints::ConstraintSet &) –> void

eval_intrares_energy(*args, **kwargs)

Overloaded function.

  1. eval_intrares_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::ConstraintSet::eval_intrares_energy(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

  1. eval_intrares_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, rsd: pyrosetta.rosetta.core.conformation.Residue, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::ConstraintSet::eval_intrares_energy(const class core::conformation::Residue &, class core::scoring::EMapVector &) const –> void

eval_multibody_atom_derivative(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, atom_id: pyrosetta.rosetta.core.id.AtomID, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.ScoreFunction, weights: pyrosetta.rosetta.core.scoring.EMapVector, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) None
evaluate the derivatives for an atom that contains 3- or higher-body

constraints. Such derivatives cannot be evalauated in an extra-posal context (e.g. such as in RTMin).

C++: core::scoring::constraints::ConstraintSet::eval_multibody_atom_derivative(const class core::id::AtomID &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::scoring::EMapVector &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

eval_non_residue_pair_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector) None
Does NOT zero the emap values, just adds the additional contribution to the

existing emap energies (so can be called inside finalize_total_energies)

C++: core::scoring::constraints::ConstraintSet::eval_non_residue_pair_energy(const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

get_all_constraints(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t
Returns all constraints in the set as a flat list, regardless of

type.

C++: core::scoring::constraints::ConstraintSet::get_all_constraints() const –> class utility::vector1<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > >

has_constraints(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) bool

C++: core::scoring::constraints::ConstraintSet::has_constraints() const –> bool

has_dof_constraints(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) bool

C++: core::scoring::constraints::ConstraintSet::has_dof_constraints() const –> bool

has_intra_residue_constraints(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) bool

C++: core::scoring::constraints::ConstraintSet::has_intra_residue_constraints() const –> bool

has_non_residue_pair_constraints(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) bool

C++: core::scoring::constraints::ConstraintSet::has_non_residue_pair_constraints() const –> bool

has_residue_pair_constraints(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) bool

C++: core::scoring::constraints::ConstraintSet::has_residue_pair_constraints() const –> bool

is_empty(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) bool

C++: core::scoring::constraints::ConstraintSet::is_empty() const –> bool

n_sequence_constraints(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) int

Get the number of sequence constraints.

C++: core::scoring::constraints::ConstraintSet::n_sequence_constraints() const –> unsigned long

on_connection_change(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, event: pyrosetta.rosetta.core.conformation.signals.ConnectionEvent) None

C++: core::scoring::constraints::ConstraintSet::on_connection_change(const struct core::conformation::signals::ConnectionEvent &) –> void

on_length_change(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, event: pyrosetta.rosetta.core.conformation.signals.LengthEvent) None

C++: core::scoring::constraints::ConstraintSet::on_length_change(const struct core::conformation::signals::LengthEvent &) –> void

remap_residue_positions(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, smap: pyrosetta.rosetta.core.id.SequenceMapping) None
remaps the constraints in this particular constraint set according

to brief the passed in sequence mapping — redundant with remapped_clone!!!

C++: core::scoring::constraints::ConstraintSet::remap_residue_positions(const class core::id::SequenceMapping &) –> void

remapped_clone(*args, **kwargs)

Overloaded function.

  1. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.ConstraintSet

  2. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose, smap: pyrosetta.rosetta.core.id.SequenceMapping) -> pyrosetta.rosetta.core.scoring.constraints.ConstraintSet

Copies the data from this ConstraintSet into a new object and

returns its OP; atoms are mapped to atoms with the same name in dest pose ( e.g. for switch from centroid to fullatom ) if a sequence_mapping is present it is used to map residue numbers .. nullptr = identity mapping to the new object. This will really clone all constraints since they have to change their atom-numbers and residue-numbers

C++: core::scoring::constraints::ConstraintSet::remapped_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::ConstraintSet>

remove_constraint(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, cst: pyrosetta.rosetta.core.scoring.constraints.Constraint, object_comparison: bool) bool
Returns true if the constraint was successfully found and removed.

if object comparison is set to true, the constraint to be removed is found through the Constraint::== operator and not through pointer comparison

C++: core::scoring::constraints::ConstraintSet::remove_constraint(class std::shared_ptr<const class core::scoring::constraints::Constraint>, bool) –> bool

remove_constraints(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, cst_list: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, object_comparison: bool) bool

C++: core::scoring::constraints::ConstraintSet::remove_constraints(class utility::vector1<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > >, bool) –> bool

residue_pair_constraint_exists(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, pos1: int, pos2: int) bool

C++: core::scoring::constraints::ConstraintSet::residue_pair_constraint_exists(const int, const int) const –> bool

residue_pair_constraints_exists(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, pos: int) bool

C++: core::scoring::constraints::ConstraintSet::residue_pair_constraints_exists(const unsigned long) const –> bool

residue_pair_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector) None

C++: core::scoring::constraints::ConstraintSet::residue_pair_energy(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

revision_id(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) int

C++: core::scoring::constraints::ConstraintSet::revision_id() const –> unsigned long

same_type_as_me(*args, **kwargs)

Overloaded function.

  1. same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, other: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) -> bool

  2. same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, other: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, recurse: bool) -> bool

Does this ConstraintSet class have the same type as the other ConstraintSet

object? If so, then the assignment operator can be used to copy constraints from one ConstraintSet into the other. Always call this with recurse set to true or unspecified – derived classes should make sure that they set this variable to false in their implementations of this method to avoid infinite recursion.

C++: core::scoring::constraints::ConstraintSet::same_type_as_me(const class core::scoring::constraints::ConstraintSet &, bool) const –> bool

sequence_constraint(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, index: int) pyrosetta.rosetta.core.scoring.aa_composition_energy.SequenceConstraint

Get the owning pointer to the Nth sequence constraint.

C++: core::scoring::constraints::ConstraintSet::sequence_constraint(const unsigned long) const –> class std::shared_ptr<const class core::scoring::aa_composition_energy::SequenceConstraint>

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose, scfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::ConstraintSet::setup_for_derivatives(class core::pose::Pose &, const class core::scoring::ScoreFunction &) const –> void

setup_for_minimizing_for_residue(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, minmap: pyrosetta.rosetta.core.kinematics.MinimizerMapBase, res_data_cache: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData) None
Cache the ConstraintsCOP for a particular residue

in the res_data_cache, under the “cst_res_data” element of the data-cache’s CachableDataOP array. Derived ConstraintSet classes should decide HERE whether any constraints should be evaluated for this residue, since, once a ConstraintsOP is added to the minimization graph, the derived class looses the chance to veto the evaluation of that constraint.

C++: core::scoring::constraints::ConstraintSet::setup_for_minimizing_for_residue(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::kinematics::MinimizerMapBase &, class core::scoring::ResSingleMinimizationData &) const –> void

setup_for_minimizing_for_residue_pair(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, minmap: pyrosetta.rosetta.core.kinematics.MinimizerMapBase, res1_data_cache: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, respair_data_cache: pyrosetta.rosetta.core.scoring.ResPairMinimizationData) None
Cache the ConstraintsCOP for a particular residue pair

in the respair_data_cache, under the “cst_respair_data” element of the data-cache’s CachableDataOP array. Derived ConstraintSet classes should decide HERE whether any constraints should be evaluated between this pair of residues, since, once a ConstraintsOP is added to the minimization graph, the derived class looses the chance to veto the evaluation of that constraint.

C++: core::scoring::constraints::ConstraintSet::setup_for_minimizing_for_residue_pair(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::kinematics::MinimizerMapBase &, const class core::scoring::ResSingleMinimizationData &, const class core::scoring::ResSingleMinimizationData &, class core::scoring::ResPairMinimizationData &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose, scfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::ConstraintSet::setup_for_scoring(class core::pose::Pose &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::ConstraintSet::show(std::ostream &) const –> void

show_definition(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::constraints::ConstraintSet::show_definition(std::ostream &, const class core::pose::Pose &) const –> void

show_numbers(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::ConstraintSet::show_numbers(std::ostream &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, verbose_level: int, threshold: float) -> int

C++: core::scoring::constraints::ConstraintSet::show_violations(std::ostream &, class core::pose::Pose &, unsigned long, double) const –> unsigned long

steal_def_clone(*args, **kwargs)

Overloaded function.

  1. steal_def_clone(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.ConstraintSet

  2. steal_def_clone(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose, smap: pyrosetta.rosetta.core.id.SequenceMapping) -> pyrosetta.rosetta.core.scoring.constraints.ConstraintSet

like remapped_clone, but constraints also steal_def from src-pose

use, e.g., to get a new set of CoordinateConstraints for given xyz coordinates in src-pose

C++: core::scoring::constraints::ConstraintSet::steal_def_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::ConstraintSet>

class pyrosetta.rosetta.core.scoring.constraints.Constraints

Bases: pybind11_builtins.pybind11_object

add_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, cst: pyrosetta.rosetta.core.scoring.constraints.Constraint) None

C++: core::scoring::constraints::Constraints::add_constraint(class std::shared_ptr<const class core::scoring::constraints::Constraint>) –> void

assign(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, rhs: pyrosetta.rosetta.core.scoring.constraints.Constraints) pyrosetta.rosetta.core.scoring.constraints.Constraints

Copy the contents of the rhs %Constraints object into this %Constraints object

C++: core::scoring::constraints::Constraints::operator=(const class core::scoring::constraints::Constraints &) –> class core::scoring::constraints::Constraints &

begin(self: pyrosetta.rosetta.core.scoring.constraints.Constraints) __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::constraints::Constraint const> const*, std::vector<std::shared_ptr<core::scoring::constraints::Constraint const>, std::allocator<std::shared_ptr<core::scoring::constraints::Constraint const> > > >

C++: core::scoring::constraints::Constraints::begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::constraints::Constraint> *, class std::vector<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > > >

clear(self: pyrosetta.rosetta.core.scoring.constraints.Constraints) None

C++: core::scoring::constraints::Constraints::clear() –> void

clone(self: pyrosetta.rosetta.core.scoring.constraints.Constraints) pyrosetta.rosetta.core.scoring.constraints.Constraints

Create a copy of this %Constraints object using the shallow-copy-constructor.

C++: core::scoring::constraints::Constraints::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraints>

conformation_energy(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, conformation: pyrosetta.rosetta.core.conformation.Conformation, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) None

C++: core::scoring::constraints::Constraints::conformation_energy(const class core::conformation::Conformation &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

constraints(self: pyrosetta.rosetta.core.scoring.constraints.Constraints) pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t

C++: core::scoring::constraints::Constraints::constraints() const –> const class utility::vector1<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > > &

deep_clone(self: pyrosetta.rosetta.core.scoring.constraints.Constraints) pyrosetta.rosetta.core.scoring.constraints.Constraints

Create a deep copy of this %Constraints object, cloning all of the individual constraints

C++: core::scoring::constraints::Constraints::deep_clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraints>

end(self: pyrosetta.rosetta.core.scoring.constraints.Constraints) __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::constraints::Constraint const> const*, std::vector<std::shared_ptr<core::scoring::constraints::Constraint const>, std::allocator<std::shared_ptr<core::scoring::constraints::Constraint const> > > >

C++: core::scoring::constraints::Constraints::end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::constraints::Constraint> *, class std::vector<class std::shared_ptr<const class core::scoring::constraints::Constraint>, class std::allocator<class std::shared_ptr<const class core::scoring::constraints::Constraint> > > >

eval_intrares_atom_derivative(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, atom_id: pyrosetta.rosetta.core.id.AtomID, residue: pyrosetta.rosetta.core.conformation.Residue, weights: pyrosetta.rosetta.core.scoring.EMapVector, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) None
Evaluate derivatives giving the Constraint objects held within this object

a single residue. Warning: if this Constraints object contains Constraint objects that operate on other residues besides the one being given them, then this function will cause the program to exit.

C++: core::scoring::constraints::Constraints::eval_intrares_atom_derivative(const class core::id::AtomID &, const class core::conformation::Residue &, const class core::scoring::EMapVector &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

eval_respair_atom_derivative(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, atom_id: pyrosetta.rosetta.core.id.AtomID, residue1: pyrosetta.rosetta.core.conformation.Residue, residue2: pyrosetta.rosetta.core.conformation.Residue, weights: pyrosetta.rosetta.core.scoring.EMapVector, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) None
Evaluate derivatives giving the Constraint objects held within this object

two residues. Warning: if this Constraints object contains Constraint objects that operate on other residues besides the two being given them, then this function will cause the program to exit.

C++: core::scoring::constraints::Constraints::eval_respair_atom_derivative(const class core::id::AtomID &, const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::scoring::EMapVector &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

eval_ws_atom_derivative(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, atom_id: pyrosetta.rosetta.core.id.AtomID, conformation: pyrosetta.rosetta.core.conformation.Conformation, weights: pyrosetta.rosetta.core.scoring.EMapVector, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) None
Evaluate derivatives giving the Constraint objects held within this object

the entire Conformation (a whole structure, ws) with which to work.

C++: core::scoring::constraints::Constraints::eval_ws_atom_derivative(const class core::id::AtomID &, const class core::conformation::Conformation &, const class core::scoring::EMapVector &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

intra_residue_energy(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, rsd: pyrosetta.rosetta.core.conformation.Residue, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) None

will fail if Residue doesnt contain all the necessary atoms

C++: core::scoring::constraints::Constraints::intra_residue_energy(const class core::conformation::Residue &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

remove_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, cst: pyrosetta.rosetta.core.scoring.constraints.Constraint, object_comparison: bool) bool

Returns true iff the constraint was successfully found and removed.

C++: core::scoring::constraints::Constraints::remove_constraint(class std::shared_ptr<const class core::scoring::constraints::Constraint>, bool) –> bool

residue_pair_energy(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) None

will fail if Residues dont contain all the necessary atoms

C++: core::scoring::constraints::Constraints::residue_pair_energy(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, xyz_func: core::scoring::func::XYZ_Func, scfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraints::setup_for_derivatives(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, xyz_func: core::scoring::func::XYZ_Func, scfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraints::setup_for_scoring(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::Constraints::show(std::ostream &) –> void

show_definition(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::constraints::Constraints::show_definition(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int, threshold: float) -> int

C++: core::scoring::constraints::Constraints::show_violations(std::ostream &, const class core::pose::Pose &, unsigned long, double) –> unsigned long

size(self: pyrosetta.rosetta.core.scoring.constraints.Constraints) int

C++: core::scoring::constraints::Constraints::size() const –> unsigned long

class pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy

Bases: pyrosetta.rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy

assign(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, : pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy) pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy

C++: core::scoring::constraints::ConstraintsEnergy::operator=(const class core::scoring::constraints::ConstraintsEnergy &) –> class core::scoring::constraints::ConstraintsEnergy &

atomistic_energy(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, atmno: int, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: core::pose::Pose, scorefxn: core::scoring::ScoreFunction, emap: core::scoring::EMapVector) None
Evaluate the (one body) energy associated with a particular atom

This may be a “self” energy, or it may be the single atom contribution from a whole structure term. NOTE: all the cautions of EnergyMethod::has_atomistic_energies() apply here. For most terms this is likely a no-op. Terms which implement this non-trivially should return true from has_atomistic_energies()

This is return-by-reference in the EnergyMap - Implementations should accumulate, not replace.

C++: core::scoring::methods::EnergyMethod::atomistic_energy(unsigned long, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

atomistic_pair_energy(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, atmno1: int, rsd1: pyrosetta.rosetta.core.conformation.Residue, atomno2: int, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: core::pose::Pose, scorefxn: core::scoring::ScoreFunction, emap: core::scoring::EMapVector) None
Evaluate the energy for a particular pair of atoms

This function may be fed the same residue with different atom numbers NOTE: all the cautions of EnergyMethod::has_atomistic_energies() apply here. For most terms this is likely a no-op. Terms which implement this non-trivially should return true from has_atomistic_pairwise_energies()

This is return-by-reference in the EnergyMap - Implementations should accumulate, not replace.

C++: core::scoring::methods::EnergyMethod::atomistic_pair_energy(unsigned long, const class core::conformation::Residue &, unsigned long, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

backbone_backbone_energy(self: pyrosetta.rosetta.core.scoring.methods.TwoBodyEnergy, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: core::pose::Pose, sfxn: core::scoring::ScoreFunction, emap: core::scoring::EMapVector) None
Evaluate the interaction between the backbone of rsd1 and the

backbone of rsd2 and accumulate the unweighted energies. The sum bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must equal the weighted result of a call to residue_pair_energy. By default, bb_bb & bb_sc return 0 and sc_sc returns residue pair energy.

C++: core::scoring::methods::TwoBodyEnergy::backbone_backbone_energy(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

backbone_sidechain_energy(self: pyrosetta.rosetta.core.scoring.methods.TwoBodyEnergy, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: core::pose::Pose, sfxn: core::scoring::ScoreFunction, emap: core::scoring::EMapVector) None
Evaluate the interaction between the backbone of rsd1 and the

sidechain of rsd2 and accumulate the unweighted energies. The sum bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must equal the unweighted result of a call to residue_pair_energy. By default, bb_bb & bb_sc return 0 and sc_sc returns residue pair energy.

C++: core::scoring::methods::TwoBodyEnergy::backbone_sidechain_energy(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

bump_energy_backbone(self: pyrosetta.rosetta.core.scoring.methods.TwoBodyEnergy, : pyrosetta.rosetta.core.conformation.Residue, : pyrosetta.rosetta.core.conformation.Residue, : core::pose::Pose, : core::scoring::ScoreFunction, : core::scoring::EMapVector) None

C++: core::scoring::methods::TwoBodyEnergy::bump_energy_backbone(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

bump_energy_full(self: pyrosetta.rosetta.core.scoring.methods.TwoBodyEnergy, : pyrosetta.rosetta.core.conformation.Residue, : pyrosetta.rosetta.core.conformation.Residue, : core::pose::Pose, : core::scoring::ScoreFunction, : core::scoring::EMapVector) None

C++: core::scoring::methods::TwoBodyEnergy::bump_energy_full(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

clone(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy) pyrosetta.rosetta.core.scoring.methods.EnergyMethod

C++: core::scoring::constraints::ConstraintsEnergy::clone() const –> class std::shared_ptr<class core::scoring::methods::EnergyMethod>

defines_high_order_terms(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, : pyrosetta.rosetta.core.pose.Pose) bool
Returns true if there are three-body or higher-body constraints that the user

has defined. High-order terms will not be correctly evaluated in RTMin or other extra-pose techniques for minimization (but will work correctly when minimizing an entire Pose).

C++: core::scoring::constraints::ConstraintsEnergy::defines_high_order_terms(const class core::pose::Pose &) const –> bool

defines_intrares_dof_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, p: pyrosetta.rosetta.core.pose.Pose) bool
The DunbrackConstraint, which adds a “constant term” to the energy for a particular

rotamer so that the particular rotamer matches the score of the best rotamer at a particular phi/psi, defines derivatives for phi and psi. or rather – it doesn’t, but it should.

C++: core::scoring::constraints::ConstraintsEnergy::defines_intrares_dof_derivatives(const class core::pose::Pose &) const –> bool

defines_intrares_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, weights: pyrosetta.rosetta.core.scoring.EMapVector) bool

C++: core::scoring::constraints::ConstraintsEnergy::defines_intrares_energy(const class core::scoring::EMapVector &) const –> bool

defines_intrares_energy_for_residue(self: pyrosetta.rosetta.core.scoring.methods.TwoBodyEnergy, res: pyrosetta.rosetta.core.conformation.Residue) bool
If a score function defines no intra-residue scores for a particular

residue, then it may opt-out of being asked during minimization to evaluate the score for this residue.

C++: core::scoring::methods::TwoBodyEnergy::defines_intrares_energy_for_residue(const class core::conformation::Residue &) const –> bool

defines_residue_pair_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, pose: pyrosetta.rosetta.core.pose.Pose, res1: int, res2: int) bool
Interface from the LongRangeTwoBodyEnergy base class; returns “true” if there’s any non-zero

or potentially non-zero interaction between a pair of residues in a pose.

C++: core::scoring::constraints::ConstraintsEnergy::defines_residue_pair_energy(const class core::pose::Pose &, unsigned long, unsigned long) const –> bool

defines_score_for_residue_pair(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, res_moving_wrt_eachother: bool) bool
Returns false if residue1 and residue2 have no inter-residue pair constraints

or if the two residues are not moving wrt each other.

C++: core::scoring::constraints::ConstraintsEnergy::defines_score_for_residue_pair(const class core::conformation::Residue &, const class core::conformation::Residue &, bool) const –> bool

eval_atom_derivative(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, id: pyrosetta.rosetta.core.id.AtomID, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, weights: pyrosetta.rosetta.core.scoring.EMapVector, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) None

called during gradient-based minimization inside dfunc

F1 and F2 are not zeroed – contributions from this atom are just summed in

C++: core::scoring::constraints::ConstraintsEnergy::eval_atom_derivative(const class core::id::AtomID &, const class core::pose::Pose &, const class ObjexxFCL::FArray1D<int> &, const class core::scoring::ScoreFunction &, const class core::scoring::EMapVector &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

eval_dof_derivative(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, id: pyrosetta.rosetta.core.id.DOF_ID, tor: pyrosetta.rosetta.core.id.TorsionID, pose: pyrosetta.rosetta.core.pose.Pose, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, weights: pyrosetta.rosetta.core.scoring.EMapVector) float

Evaluate dof derivatives when DOF_constraints are in use

C++: core::scoring::constraints::ConstraintsEnergy::eval_dof_derivative(const class core::id::DOF_ID &, const class core::id::TorsionID &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::scoring::EMapVector &) const –> double

eval_intrares_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, min_data: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector, atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair) None

C++: core::scoring::constraints::ConstraintsEnergy::eval_intrares_derivatives(const class core::conformation::Residue &, const class core::scoring::ResSingleMinimizationData &, const class core::pose::Pose &, const class core::scoring::EMapVector &, class utility::vector1<class core::scoring::DerivVectorPair, class std::allocator<class core::scoring::DerivVectorPair> > &) const –> void

eval_intrares_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector) None

Evaluate the intra-residue constraint energy for a given residue

C++: core::scoring::constraints::ConstraintsEnergy::eval_intrares_energy(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

eval_intrares_energy_ext(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, data_cache: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector) None

Evaluate the intra-residue energies using ConstraintCOPs cached in the data_cache object

C++: core::scoring::constraints::ConstraintsEnergy::eval_intrares_energy_ext(const class core::conformation::Residue &, const class core::scoring::ResSingleMinimizationData &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

eval_intraresidue_dof_derivative(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, min_data: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, dof_id: pyrosetta.rosetta.core.id.DOF_ID, torsion_id: pyrosetta.rosetta.core.id.TorsionID, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, weights: pyrosetta.rosetta.core.scoring.EMapVector) float
Evaluate the DOF derivative for a particular residue. The Pose merely serves as context,

and the input residue is not required to be a member of the Pose.

C++: core::scoring::constraints::ConstraintsEnergy::eval_intraresidue_dof_derivative(const class core::conformation::Residue &, const class core::scoring::ResSingleMinimizationData &, const class core::id::DOF_ID &, const class core::id::TorsionID &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::scoring::EMapVector &) const –> double

eval_residue_pair_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, : pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, : pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, min_data: pyrosetta.rosetta.core.scoring.ResPairMinimizationData, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector, r1_atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair) None

C++: core::scoring::constraints::ConstraintsEnergy::eval_residue_pair_derivatives(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::scoring::ResSingleMinimizationData &, const class core::scoring::ResSingleMinimizationData &, const class core::scoring::ResPairMinimizationData &, const class core::pose::Pose &, const class core::scoring::EMapVector &, class utility::vector1<class core::scoring::DerivVectorPair, class std::allocator<class core::scoring::DerivVectorPair> > &, class utility::vector1<class core::scoring::DerivVectorPair, class std::allocator<class core::scoring::DerivVectorPair> > &) const –> void

evaluate_rotamer_background_energies(self: pyrosetta.rosetta.core.scoring.methods.TwoBodyEnergy, set: pyrosetta.rosetta.core.conformation.RotamerSetBase, residue: pyrosetta.rosetta.core.conformation.Residue, pose: core::pose::Pose, sfxn: core::scoring::ScoreFunction, weights: core::scoring::EMapVector, energy_vector: pyrosetta.rosetta.utility.vector1_float) None
Batch computation of rotamer/background energies. Need not be overriden

in derived class – by default, iterates over all rotamers in the set, and calls derived class’s residue_pair_energy method for each one against the background rotamr

C++: core::scoring::methods::TwoBodyEnergy::evaluate_rotamer_background_energies(const class core::conformation::RotamerSetBase &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::scoring::EMapVector &, class utility::vector1<float, class std::allocator<float> > &) const –> void

evaluate_rotamer_background_energy_maps(self: pyrosetta.rosetta.core.scoring.methods.TwoBodyEnergy, set: pyrosetta.rosetta.core.conformation.RotamerSetBase, residue: pyrosetta.rosetta.core.conformation.Residue, pose: core::pose::Pose, sfxn: core::scoring::ScoreFunction, weights: core::scoring::EMapVector, emaps: pyrosetta.rosetta.utility.vector1_core_scoring_EMapVector) None
Batch computation of rotamer/background energies. Need not be overriden

in derived class – by default, iterates over all rotamers in the set, and calls derived class’s residue_pair_energy method for each one against the background rotamr

C++: core::scoring::methods::TwoBodyEnergy::evaluate_rotamer_background_energy_maps(const class core::conformation::RotamerSetBase &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::scoring::EMapVector &, class utility::vector1<class core::scoring::EMapVector, class std::allocator<class core::scoring::EMapVector> > &) const –> void

evaluate_rotamer_intrares_energies(self: pyrosetta.rosetta.core.scoring.methods.TwoBodyEnergy, set: pyrosetta.rosetta.core.conformation.RotamerSetBase, pose: core::pose::Pose, sfxn: core::scoring::ScoreFunction, energies: pyrosetta.rosetta.utility.vector1_float) None
Batch computation of rotamer intrares energies. Need not be overriden in

derived class – by default, iterates over all rotamers, and calls derived class’s intrares _energy method.

C++: core::scoring::methods::TwoBodyEnergy::evaluate_rotamer_intrares_energies(const class core::conformation::RotamerSetBase &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class utility::vector1<float, class std::allocator<float> > &) const –> void

evaluate_rotamer_intrares_energy_maps(self: pyrosetta.rosetta.core.scoring.methods.TwoBodyEnergy, set: pyrosetta.rosetta.core.conformation.RotamerSetBase, pose: core::pose::Pose, sfxn: core::scoring::ScoreFunction, emaps: pyrosetta.rosetta.utility.vector1_core_scoring_EMapVector) None
Batch computation of rotamer intrares energy map. Need not be overriden in

derived class – by default, iterates over all rotamers, and calls derived class’s intrares _energy method.

C++: core::scoring::methods::TwoBodyEnergy::evaluate_rotamer_intrares_energy_maps(const class core::conformation::RotamerSetBase &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class utility::vector1<class core::scoring::EMapVector, class std::allocator<class core::scoring::EMapVector> > &) const –> void

evaluate_rotamer_pair_energies(self: pyrosetta.rosetta.core.scoring.methods.TwoBodyEnergy, set1: pyrosetta.rosetta.core.conformation.RotamerSetBase, set2: pyrosetta.rosetta.core.conformation.RotamerSetBase, pose: core::pose::Pose, sfxn: core::scoring::ScoreFunction, weights: core::scoring::EMapVector, energy_table: pyrosetta.rosetta.ObjexxFCL.FArray2D_float_t) None
Batch computation of rotamer pair energies. Need not be overriden in

derived class – by default, iterates over all pairs of rotamers, and calls the derived class’s residue_pair_energy method.

C++: core::scoring::methods::TwoBodyEnergy::evaluate_rotamer_pair_energies(const class core::conformation::RotamerSetBase &, const class core::conformation::RotamerSetBase &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::scoring::EMapVector &, class ObjexxFCL::FArray2D<float> &) const –> void

finalize_after_derivatives(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : core::pose::Pose, : core::scoring::ScoreFunction) None

called at the end of derivatives evaluation

C++: core::scoring::methods::EnergyMethod::finalize_after_derivatives(class core::pose::Pose &, const class core::scoring::ScoreFunction &) const –> void

finalize_after_minimizing(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, pose: core::pose::Pose) None
Called after minimization, allowing a derived class to do some

teardown steps.

Base class function does nothing. Derived classes may override.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::methods::EnergyMethod::finalize_after_minimizing(class core::pose::Pose &) const –> void

finalize_total_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.ScoreFunction, totals: pyrosetta.rosetta.core.scoring.EMapVector) None

called at the end of energy evaluation

C++: core::scoring::constraints::ConstraintsEnergy::finalize_total_energy(class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

has_atomistic_energies(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod) bool
Does this EnergyMethod have a non-trivial implementation of the (one body) atomistic energy method?

Note that this may return false even if the score term theoretically could support atomistic energies. And even if this function returns true, it’s not necessarily the case that all atoms will get assigned an energy, or that the sum over all atoms (or atom pairs) will result in the same energy as the residue-level approach. The atomistic functions are intended for supplemental informational purposes only. The residue-level energies are the main interface for EnergyMethods.

C++: core::scoring::methods::EnergyMethod::has_atomistic_energies() const –> bool

has_atomistic_pairwise_energies(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod) bool
Does this EnergyMethod have a non-trivial implementation of the pairwise atomistic energy method?

NOTE: all the cautions of EnergyMethod::has_atomistic_energies() apply here.

C++: core::scoring::methods::EnergyMethod::has_atomistic_pairwise_energies() const –> bool

indicate_required_context_graphs(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, : pyrosetta.rosetta.utility.vector1_bool) None

C++: core::scoring::constraints::ConstraintsEnergy::indicate_required_context_graphs(class utility::vector1<bool, class std::allocator<bool> > &) const –> void

long_range_type(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy) pyrosetta.rosetta.core.scoring.methods.LongRangeEnergyType
Identification for this LR2B energy that links it with the

long-range energy container that it stores in the Energies object

C++: core::scoring::constraints::ConstraintsEnergy::long_range_type() const –> enum core::scoring::methods::LongRangeEnergyType

method_type(self: pyrosetta.rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) pyrosetta.rosetta.core.scoring.methods.EnergyMethodType

C++: core::scoring::methods::ContextIndependentLRTwoBodyEnergy::method_type() const –> enum core::scoring::methods::EnergyMethodType

minimize_in_whole_structure_context(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, : pyrosetta.rosetta.core.pose.Pose) bool

C++: core::scoring::constraints::ConstraintsEnergy::minimize_in_whole_structure_context(const class core::pose::Pose &) const –> bool

prepare_constraints_energy_container(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::constraints::ConstraintsEnergy::prepare_constraints_energy_container(class core::pose::Pose &) const –> void

prepare_rotamers_for_packing(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : core::pose::Pose, : pyrosetta.rosetta.core.conformation.RotamerSetBase) None
If an energy method needs to cache data in a packing::RotamerSet object before

rotamer energies are calculated, it does so during this function. The packer must ensure this function is called. The default behavior is to do nothing.

C++: core::scoring::methods::EnergyMethod::prepare_rotamers_for_packing(const class core::pose::Pose &, class core::conformation::RotamerSetBase &) const –> void

provide_citation_info(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) None
Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by energy methods wishing to provide citation information.

C++: core::scoring::methods::EnergyMethod::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

requires_a_setup_for_derivatives_for_residue_opportunity(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, pose: pyrosetta.rosetta.core.pose.Pose) bool
Does this EnergyMethod require the opportunity to examine each residue before derivative evaluation begins? Not

all energy methods would. The ScoreFunction will not ask energy methods to examine residue pairs that are uninterested in doing so.

C++: core::scoring::constraints::ConstraintsEnergy::requires_a_setup_for_derivatives_for_residue_opportunity(const class core::pose::Pose &) const –> bool

requires_a_setup_for_derivatives_for_residue_pair_opportunity(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, pose: pyrosetta.rosetta.core.pose.Pose) bool

Ask for the opportunity to setup for derivative evaluation

C++: core::scoring::constraints::ConstraintsEnergy::requires_a_setup_for_derivatives_for_residue_pair_opportunity(const class core::pose::Pose &) const –> bool

requires_a_setup_for_scoring_for_residue_opportunity_during_minimization(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, pose: pyrosetta.rosetta.core.pose.Pose) bool

Ask for the opportunity to setup for scoring for evaluating 1-body constraints

C++: core::scoring::constraints::ConstraintsEnergy::requires_a_setup_for_scoring_for_residue_opportunity_during_minimization(const class core::pose::Pose &) const –> bool

requires_a_setup_for_scoring_for_residue_opportunity_during_regular_scoring(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, pose: core::pose::Pose) bool
Does this EnergyMethod require the opportunity to examine the residue before (regular) scoring begins? Not

all energy methods would. The ScoreFunction will not ask energy methods to examine residues that are uninterested in doing so. The default implmentation of this function returns false

C++: core::scoring::methods::EnergyMethod::requires_a_setup_for_scoring_for_residue_opportunity_during_regular_scoring(const class core::pose::Pose &) const –> bool

requires_a_setup_for_scoring_for_residue_pair_opportunity(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, pose: pyrosetta.rosetta.core.pose.Pose) bool

Request the opportunity to setup for scoring

C++: core::scoring::constraints::ConstraintsEnergy::requires_a_setup_for_scoring_for_residue_pair_opportunity(const class core::pose::Pose &) const –> bool

residue_pair_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector) None

C++: core::scoring::constraints::ConstraintsEnergy::residue_pair_energy(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

residue_pair_energy_ext(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, min_data: pyrosetta.rosetta.core.scoring.ResPairMinimizationData, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector) None
The ConstraintsEnergy caches all residue-pair constraints operating between a particular

pair of residues in the min_data object so that it does not need to search for those constraints when scoring during minimization.

C++: core::scoring::constraints::ConstraintsEnergy::residue_pair_energy_ext(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::scoring::ResPairMinimizationData &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

score_types(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod) pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

Returns the score types that this energy method computes.

C++: core::scoring::methods::EnergyMethod::score_types() const –> const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, pose: pyrosetta.rosetta.core.pose.Pose, scfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::ConstraintsEnergy::setup_for_derivatives(class core::pose::Pose &, const class core::scoring::ScoreFunction &) const –> void

setup_for_derivatives_for_residue(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, min_data: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, res_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache) None

Do any setup work necessary before evaluating the derivatives for this residue

C++: core::scoring::constraints::ConstraintsEnergy::setup_for_derivatives_for_residue(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::ResSingleMinimizationData &, class basic::datacache::BasicDataCache &) const –> void

setup_for_derivatives_for_residue_pair(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, minsingle_data1: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, data_cache: pyrosetta.rosetta.core.scoring.ResPairMinimizationData) None

Do any setup work necessary before evaluating the derivatives for this residue pair

C++: core::scoring::constraints::ConstraintsEnergy::setup_for_derivatives_for_residue_pair(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::scoring::ResSingleMinimizationData &, const class core::scoring::ResSingleMinimizationData &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::ResPairMinimizationData &) const –> void

setup_for_minimizing(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : core::pose::Pose, : core::scoring::ScoreFunction, : core::kinematics::MinimizerMapBase) None
Called at the beginning of atom tree minimization, this method

allows the derived class the opportunity to initialize pertinent data that will be used during minimization. During minimzation, the chemical structure of the pose is constant, so assumptions on the number of atoms per residue and their identities are safe so long as the pose’s Energies object’s “use_nblist()” method returns true.

C++: core::scoring::methods::EnergyMethod::setup_for_minimizing(class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::kinematics::MinimizerMapBase &) const –> void

setup_for_minimizing_for_residue(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, minmap: pyrosetta.rosetta.core.kinematics.MinimizerMapBase, : pyrosetta.rosetta.basic.datacache.BasicDataCache, res_data_cache: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData) None
Cache the intra-residue constraints in the ResSingleMinimizationData object

for rapid retrieval during minimization and allow the constraints to store data in the res_data_cache if they need to.

C++: core::scoring::constraints::ConstraintsEnergy::setup_for_minimizing_for_residue(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::kinematics::MinimizerMapBase &, class basic::datacache::BasicDataCache &, class core::scoring::ResSingleMinimizationData &) const –> void

setup_for_minimizing_for_residue_pair(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, minmap: pyrosetta.rosetta.core.kinematics.MinimizerMapBase, res1_data_cache: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, respair_data_cache: pyrosetta.rosetta.core.scoring.ResPairMinimizationData) None
Cache the residue-pair constraints in the ResPairMinimizationData object

for rapid retrieval during minimization and allow constraints to cache useful data in the respair_data_cache if they need to

C++: core::scoring::constraints::ConstraintsEnergy::setup_for_minimizing_for_residue_pair(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::kinematics::MinimizerMapBase &, const class core::scoring::ResSingleMinimizationData &, const class core::scoring::ResSingleMinimizationData &, class core::scoring::ResPairMinimizationData &) const –> void

setup_for_packing(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, pose: pyrosetta.rosetta.core.pose.Pose, residues_repacking: pyrosetta.rosetta.utility.vector1_bool, residues_designing: pyrosetta.rosetta.utility.vector1_bool) None

Make sure that the ConstraintsEnergyContainer is ready for packing.

C++: core::scoring::constraints::ConstraintsEnergy::setup_for_packing(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, const class utility::vector1<bool, class std::allocator<bool> > &) const –> void

setup_for_packing_with_rotsets(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, pose: core::pose::Pose, rotsets: core::pack_basic::RotamerSetsBase, sfxn: core::scoring::ScoreFunction) None
if an energy method needs to cache data in the Energies object,

before packing begins and requires access to the RotamerSets object, then it does so during this function. The default behavior is to do nothing.

The exact order of events when setting up for packing are as follows:
  1. setup_for_packing() is called for all energy methods

  2. rotamers are built

  3. setup_for_packing_with_rotsets() is called for all energy methods

  4. prepare_rotamers_for_packing() is called for all energy methods

  5. The energy methods are asked to score all rotamers and rotamer pairs

  6. Annealing

The pose is specifically non-const here so that energy methods can store data in it

: Used in ApproximateBuriedUnsatPenalty to pre-compute compatible rotamers

C++: core::scoring::methods::EnergyMethod::setup_for_packing_with_rotsets(class core::pose::Pose &, const class std::shared_ptr<class core::pack_basic::RotamerSetsBase> &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, pose: pyrosetta.rosetta.core.pose.Pose, scfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::ConstraintsEnergy::setup_for_scoring(class core::pose::Pose &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring_for_residue(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, min_data: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData) None

Allow the component constraints to setup for scoring for a particular residue

C++: core::scoring::constraints::ConstraintsEnergy::setup_for_scoring_for_residue(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::ResSingleMinimizationData &) const –> void

setup_for_scoring_for_residue_pair(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, minsingle_data1: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, data_cache: pyrosetta.rosetta.core.scoring.ResPairMinimizationData) None
Do any setup work should the coordinates of a pair of residues, who are still guaranteed to be

of the same residue type as when setup_for_minimizing_for_residue was called, have changed so dramatically as to possibly require some amount of setup work before scoring should proceed

C++: core::scoring::constraints::ConstraintsEnergy::setup_for_scoring_for_residue_pair(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::scoring::ResSingleMinimizationData &, const class core::scoring::ResSingleMinimizationData &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::ResPairMinimizationData &) const –> void

show_additional_info(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : pyrosetta.rosetta.std.ostream, : core::pose::Pose, : bool) None

show additional information of the energy method

C++: core::scoring::methods::EnergyMethod::show_additional_info(std::ostream &, class core::pose::Pose &, bool) const –> void

sidechain_sidechain_energy(self: pyrosetta.rosetta.core.scoring.methods.TwoBodyEnergy, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: core::pose::Pose, sfxn: core::scoring::ScoreFunction, emap: core::scoring::EMapVector) None
Evaluate the interaction between the sidechain of rsd1 and the

sidechain of rsd2 and accumulate the unweighted energies. The sum bb_bb(r1,r2) + bb_sc(r1,r2) + bb_sc(r2,r1) + sc_sc( r1,r2) must equal the unweighted result of a call to residue_pair_energy. By default, bb_bb & bb_sc return 0 and sc_sc returns residue pair energy.

C++: core::scoring::methods::TwoBodyEnergy::sidechain_sidechain_energy(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) const –> void

update_residue_for_packing(self: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, : core::pose::Pose, resid: int) None
If the pose changes in the middle of a packing (as happens in rotamer trials) and if

an energy method needs to cache data in the pose that corresponds to its current state, then the method must update that data when this function is called. The packer must ensure this function gets called. The default behavior is to do nothing.

C++: core::scoring::methods::EnergyMethod::update_residue_for_packing(class core::pose::Pose &, unsigned long) const –> void

use_extended_intrares_energy_interface(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy) bool
request of minimization routines that they use the extended intraresidue energy

interface

C++: core::scoring::constraints::ConstraintsEnergy::use_extended_intrares_energy_interface() const –> bool

use_extended_residue_pair_energy_interface(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy) bool
Returns true as the ConstraintsEnergy caches its residue pair constraints in

the ResPairMinimicationData objects stored on edges in the MinimizationGraph

C++: core::scoring::constraints::ConstraintsEnergy::use_extended_residue_pair_energy_interface() const –> bool

version(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergy) int

C++: core::scoring::constraints::ConstraintsEnergy::version() const –> unsigned long

class pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergyCreator

Bases: pyrosetta.rosetta.core.scoring.methods.EnergyMethodCreator

assign(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergyCreator, : pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergyCreator) pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergyCreator

C++: core::scoring::constraints::ConstraintsEnergyCreator::operator=(const class core::scoring::constraints::ConstraintsEnergyCreator &) –> class core::scoring::constraints::ConstraintsEnergyCreator &

create_energy_method(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergyCreator, : pyrosetta.rosetta.core.scoring.methods.EnergyMethodOptions) pyrosetta.rosetta.core.scoring.methods.EnergyMethod

Instantiate a new ConstraintsEnergy

C++: core::scoring::constraints::ConstraintsEnergyCreator::create_energy_method(const class core::scoring::methods::EnergyMethodOptions &) const –> class std::shared_ptr<class core::scoring::methods::EnergyMethod>

score_types_for_method(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintsEnergyCreator) pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType
Return the set of score types claimed by the EnergyMethod

this EnergyMethodCreator creates in its create_energy_method() function

C++: core::scoring::constraints::ConstraintsEnergyCreator::score_types_for_method() const –> class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> >

class pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint

Bases: pyrosetta.rosetta.core.scoring.constraints.Constraint

CoordinateConstraint compares the coordinates of a given atom (AtomID atom_) to a fixed coordinate triplet (Vector xyz_target_). Its other argument, fixed_atom_, is somewhat nonobvious. CoordinateConstraints are meant to be used with a Pose that has a nonmoving virtual root residue. An AtomID in this virtual root residue should be passed as fixed_atom_. CoordinateConstraint does not use fixed_atom_, but the ScoreFunction code detects when fixed_atom_ and atom_ move relative to one another, and trigger re-scoring at that time. In other words, CoordinateConstraints are really context-independent one body energies, but we wish them to be evaluated as context-independent two-body energies. (Ideally, ScoreFunction would detect when atom_ moves relative to xyz_target_, but since ScoreFunction functions on atoms and not floating coordinate triplets, this is a good workaround.) – SML

Would be good to have something like StubCoordinateConstraint that allows definition of (x,y,z) of

moving atom to be defined in coordinate system defined by three “stub” atoms. Shows up when treating the effects of missing loops. Working out a sketch of this as a ‘standalone’ in rna::StubCoordinateHack, but should ideally integrate into Constraint machinery.

atom(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, n: int) pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::constraints::CoordinateConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

choose_effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, : numeric::random::RandomGenerator) int

C++: core::scoring::constraints::Constraint::choose_effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &, class numeric::random::RandomGenerator &) –> unsigned long

clone(*args, **kwargs)

Overloaded function.

  1. clone(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::CoordinateConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

  1. clone(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, : pyrosetta.rosetta.core.scoring.func.Func) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::CoordinateConstraint::clone(class std::shared_ptr<class core::scoring::func::Func>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)

Overloaded function.

  1. dist(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float

  2. dist(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, xyz: core::scoring::func::XYZ_Func) -> float

C++: core::scoring::constraints::CoordinateConstraint::dist(const class core::scoring::func::XYZ_Func &) const –> double

effective_sequence_separation(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) int

C++: core::scoring::constraints::Constraint::effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &) const –> unsigned long

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, atom: pyrosetta.rosetta.core.id.AtomID, xyz: core::scoring::func::XYZ_Func, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t, weights: pyrosetta.rosetta.core.scoring.EMapVector) None

C++: core::scoring::constraints::CoordinateConstraint::fill_f1_f2(const class core::id::AtomID &, const class core::scoring::func::XYZ_Func &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, const class core::scoring::EMapVector &) const –> void

get_func(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint) pyrosetta.rosetta.core.scoring.func.Func

Returns the func::Func object associated with this Constraint object.

C++: core::scoring::constraints::CoordinateConstraint::get_func() const –> const class core::scoring::func::Func &

natoms(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint) int

C++: core::scoring::constraints::CoordinateConstraint::natoms() const –> unsigned long

non_virtual_score(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, xyz: pyrosetta.rosetta.numeric.xyzVector_double_t) float

C++: core::scoring::constraints::CoordinateConstraint::non_virtual_score(const class numeric::xyzVector<double> &) const –> double

read_constraint(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose) None
This method is totally redundant with read_def YAY

DON’T USE THIS ONE.. Most Constraint classes have not overloaded this one, but read_def ! OL

C++: core::scoring::constraints::Constraint::read_constraint(std::istream &, const class core::pose::Pose &) –> void

read_data(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : pyrosetta.rosetta.std.istream) None
initialize this Constraint from the given std::istream. It’s amazing

that there are three functions for doing this inside of Constraint.hh. SO WHAT IS THIS SUPPOSED TO DO ? not overloaded by e.g., AtomPairConstraint or CoordinateConstraint,

C++: core::scoring::constraints::Constraint::read_data(std::istream &) –> void

read_def(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.func.FuncFactory) None

C++: core::scoring::constraints::CoordinateConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::CoordinateConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)

Overloaded function.

  1. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

  2. remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose, map: pyrosetta.rosetta.core.id.SequenceMapping) -> pyrosetta.rosetta.core.scoring.constraints.Constraint

Copies the data from this Constraint into a new object and returns an OP

atoms are mapped to atoms with the same name in dest pose ( e.g. for switch from centroid to fullatom ) if a sequence_mapping is present it is used to map residue numbers .. nullptr = identity mapping to the new object. Intended to be implemented by derived classes.

C++: core::scoring::constraints::CoordinateConstraint::remapped_clone(const class core::pose::Pose &, const class core::pose::Pose &, class std::shared_ptr<const class core::id::SequenceMapping>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

residues(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the pose numbers of the residues involved in this constraint, in no particular order.

Used in determining one-body/two-body/multi-body status. For historical reasons, the default uses a simple protocol based on natoms()/atom() - feel free to reimplement more efficiently.

C++: core::scoring::constraints::Constraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) bool

C++: core::scoring::constraints::CoordinateConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)

Overloaded function.

  1. score(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float

  2. score(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float

  3. score(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, xyz: core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::CoordinateConstraint::score(const class core::scoring::func::XYZ_Func &, const class core::scoring::EMapVector &, class core::scoring::EMapVector &) const –> void

score_type(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) pyrosetta.rosetta.core.scoring.ScoreType

Returns the ScoreType that this Constraint object will use.

C++: core::scoring::constraints::Constraint::score_type() const –> const enum core::scoring::ScoreType &

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_derivatives(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::constraints::Constraint::setup_for_scoring(const class core::scoring::func::XYZ_Func &, const class core::scoring::ScoreFunction &) const –> void

show(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::constraints::CoordinateConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::constraints::CoordinateConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)

Overloaded function.

  1. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int

  2. show_violations(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int, threshold: float) -> int

C++: core::scoring::constraints::CoordinateConstraint::show_violations(std::ostream &, const class core::pose::Pose &, unsigned long, double) const –> unsigned long

steal_def(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, : pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::constraints::CoordinateConstraint::steal_def(const class core::pose::Pose &) –> void

to_string(self: pyrosetta.rosetta.core.scoring.constraints.Constraint) str
Convenience function, returns the results of show() as a string.

Not to be overriden by derived classes.

C++: core::scoring::constraints::Constraint::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint) str

C++: core::scoring::constraints::CoordinateConstraint::type() const –> std::string

xyz_target(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint) pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::constraints::CoordinateConstraint::xyz_target() const –> const class numeric::xyzVector<double> &

class pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraintCreator

Bases: pyrosetta.rosetta.core.scoring.constraints.ConstraintCreator

Constraint creator for the CoordinateConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraintCreator

C++: core::scoring::constraints::CoordinateConstraintCreator::operator=(const class core::scoring::constraints::CoordinateConstraintCreator &) –> class core::scoring::constraints::CoordinateConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraintCreator) pyrosetta.rosetta.core.scoring.constraints.Constraint

C++: core::scoring::constraints::CoordinateConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraintCreator) str

C++: core::scoring::constraints::CoordinateConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer

Bases: pyrosetta.rosetta.core.scoring.LREnergyContainer

any_neighbors_for_residue(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer, resid: int) bool

C++: core::scoring::constraints::CstEnergyContainer::any_neighbors_for_residue(int) const –> bool

any_upper_neighbors_for_residue(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer, resid: int) bool

C++: core::scoring::constraints::CstEnergyContainer::any_upper_neighbors_for_residue(int) const –> bool

assign(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer, : pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer) pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer

C++: core::scoring::constraints::CstEnergyContainer::operator=(const class core::scoring::constraints::CstEnergyContainer &) –> class core::scoring::constraints::CstEnergyContainer &

clone(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer) pyrosetta.rosetta.core.scoring.LREnergyContainer

C++: core::scoring::constraints::CstEnergyContainer::clone() const –> class std::shared_ptr<class core::scoring::LREnergyContainer>

const_neighbor_iterator_begin(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer, resid: int) pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

C++: core::scoring::constraints::CstEnergyContainer::const_neighbor_iterator_begin(int) const –> class std::shared_ptr<class core::scoring::ResidueNeighborConstIterator>

const_neighbor_iterator_end(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer, resid: int) pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

C++: core::scoring::constraints::CstEnergyContainer::const_neighbor_iterator_end(int) const –> class std::shared_ptr<class core::scoring::ResidueNeighborConstIterator>

const_upper_neighbor_iterator_begin(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer, resid: int) pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

C++: core::scoring::constraints::CstEnergyContainer::const_upper_neighbor_iterator_begin(int) const –> class std::shared_ptr<class core::scoring::ResidueNeighborConstIterator>

const_upper_neighbor_iterator_end(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer, resid: int) pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

C++: core::scoring::constraints::CstEnergyContainer::const_upper_neighbor_iterator_end(int) const –> class std::shared_ptr<class core::scoring::ResidueNeighborConstIterator>

empty(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer) bool

C++: core::scoring::constraints::CstEnergyContainer::empty() const –> bool

matches(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer, cst_set: core::scoring::constraints::ConstraintSet) bool
Does the constraint graph that this CEC defines match up with the constraint set stored

in the pose?

C++: core::scoring::constraints::CstEnergyContainer::matches(class std::shared_ptr<const class core::scoring::constraints::ConstraintSet>) –> bool

neighbor_iterator_begin(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer, resid: int) pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

C++: core::scoring::constraints::CstEnergyContainer::neighbor_iterator_begin(int) –> class std::shared_ptr<class core::scoring::ResidueNeighborIterator>

neighbor_iterator_end(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer, resid: int) pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

C++: core::scoring::constraints::CstEnergyContainer::neighbor_iterator_end(int) –> class std::shared_ptr<class core::scoring::ResidueNeighborIterator>

set_num_nodes(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer, : int) None

C++: core::scoring::constraints::CstEnergyContainer::set_num_nodes(unsigned long) –> void

upper_neighbor_iterator_begin(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer, resid: int) pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

C++: core::scoring::constraints::CstEnergyContainer::upper_neighbor_iterator_begin(int) –> class std::shared_ptr<class core::scoring::ResidueNeighborIterator>

upper_neighbor_iterator_end(self: pyrosetta.rosetta.core.scoring.constraints.CstEnergyContainer, resid: int) pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

C++: core::scoring::constraints::CstEnergyContainer::upper_neighbor_iterator_end(int) –> class std::shared_ptr<class core::scoring::ResidueNeighborIterator>

class pyrosetta.rosetta.core.scoring.constraints.CstMinimizationData

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

assign(self: pyrosetta.rosetta.core.scoring.constraints.CstMinimizationData, : pyrosetta.rosetta.core.scoring.constraints.CstMinimizationData) pyrosetta.rosetta.core.scoring.constraints.CstMinimizationData

C++: core::scoring::constraints::CstMinimizationData::operator=(const class core::scoring::constraints::CstMinimizationData &) –> class core::scoring::constraints::CstMinimizationData &

clone(self: pyrosetta.rosetta.core.scoring.constraints.CstMinimizationData) pyrosetta.rosetta.basic.datacache.CacheableData

C++: core::scoring::constraints::CstMinimizationData::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

constraints(self: pyrosetta.rosetta.core.scoring.constraints.CstMinimizationData) pyrosetta.rosetta.core.scoring.constraints.Constraints

C++: core::scoring::constraints::CstMinimizationData::constraints() const –> const class core::scoring::constraints::Constraints &

get_self_ptr(self: