constraints¶

Bindings for core::scoring::constraints namespace

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

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

dist(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
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.

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

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int
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: 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: 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.

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>

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.

dist(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
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.

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

score(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int
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: 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: 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.

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>

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.

dist(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
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.

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

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

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.

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

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.

score(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int
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: 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: 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.

dist(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
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.

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

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.

score(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
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

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

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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int
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: 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: 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.

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>

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.

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

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.

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

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.

score(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
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

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

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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int
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: 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: 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.

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

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.

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>

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.

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

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.

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

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.

score(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
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

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

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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AtomToAxisConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int
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: 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.

dist(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
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.

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

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.

score(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int
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: 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.

dist(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
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.

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

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.

score(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.BackboneStubLinearConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int
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: 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.

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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.BasePairConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int
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: 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: 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.

dist(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
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.

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.

score(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.BigBinConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int
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: 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: 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.

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

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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.BoundFunc, out: pyrosetta.rosetta.std.ostream, x: float, verbose_level: int) -> int
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: 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.

dist(self: pyrosetta.rosetta.core.scoring.constraints.ConstantConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
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.

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.

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

compute score

C++: core::scoring::constraints::ConstantConstraint::score() const –> double

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_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.

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.

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>

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.

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

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

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

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.

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.

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

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

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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int
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_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: Edge

angle_constraint_energy(*args, **kwargs)¶

Overloaded function.

angle_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::angle_constraint_energy(double) –> void

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.

atom_pair_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::atom_pair_constraint_energy(double) –> void

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.

backbone_stub_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::backbone_stub_constraint_energy(double) –> void

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.

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

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.

base_pair_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::base_pair_constraint_energy(double) –> void

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.

bond_geometry_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::bond_geometry_energy(double) –> void

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.

coordinate_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::coordinate_constraint_energy(double) –> void

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.

dihedral_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::dihedral_constraint_energy(double) –> void

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.

energy_computed(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, setting: bool) -> None

C++: core::scoring::constraints::ConstraintEdge::energy_computed(bool) –> void

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.

metalbinding_constraint_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::metalbinding_constraint_energy(double) –> void

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.

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

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.

rna_bond_geometry_energy(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintEdge, : float) -> None

C++: core::scoring::constraints::ConstraintEdge::rna_bond_geometry_energy(double) –> void

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

add_edge(*args, **kwargs)¶

Overloaded function.

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 *

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

parse_atom_pair_constraint(data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint
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.

parse_coordinate_constraint(data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint
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.

parse_residue(pose: pyrosetta.rosetta.core.pose.Pose, residue_string: str, residue_num: int) -> None
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

parse_residue(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int) -> int
parse_residue(pose: pyrosetta.rosetta.core.pose.Pose, resnum: int, chain: str) -> int
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.

read_constraints(filename: str, cst_set: core::scoring::constraints::ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::constraints::ConstraintSet
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>

read_constraints(data: pyrosetta.rosetta.std.istream, cst_set: core::scoring::constraints::ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::constraints::ConstraintSet
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.

read_constraints_new(fname: str, cset: core::scoring::constraints::ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::constraints::ConstraintSet
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>

read_constraints_new(data: pyrosetta.rosetta.std.istream, cset: core::scoring::constraints::ConstraintSet, pose: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::constraints::ConstraintSet
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.

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

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

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

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

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

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.

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

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

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.

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

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, other: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet) -> bool
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

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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.ConstraintSet, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int
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.

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
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_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 &

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>

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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraints, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int
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: 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

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

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:

setup_for_packing() is called for all energy methods
rotamers are built
setup_for_packing_with_rotsets() is called for all energy methods
prepare_rotamers_for_packing() is called for all energy methods
The energy methods are asked to score all rotamers and rotamer pairs
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

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

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>

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.

dist(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
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.

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

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.

score(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.CoordinateConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int
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: 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: 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: 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: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t¶: C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

set_constraints(self: pyrosetta.rosetta.core.scoring.constraints.CstMinimizationData, constraints: pyrosetta.rosetta.core.scoring.constraints.Constraints) → None¶: C++: core::scoring::constraints::CstMinimizationData::set_constraints(class std::shared_ptr<class core::scoring::constraints::Constraints>) –> void

class pyrosetta.rosetta.core.scoring.constraints.CstResNeighbConstIterator¶

Bases: ResidueNeighborConstIterator

accumulate_energy(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbConstIterator, : pyrosetta.rosetta.core.scoring.EMapVector) → None¶: C++: core::scoring::constraints::CstResNeighbConstIterator::accumulate_energy(class core::scoring::EMapVector &) const –> void

assign(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbConstIterator, : pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator¶: C++: core::scoring::constraints::CstResNeighbConstIterator::operator=(const class core::scoring::ResidueNeighborConstIterator &) –> class core::scoring::ResidueNeighborConstIterator &

energy_computed(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbConstIterator) → bool¶: C++: core::scoring::constraints::CstResNeighbConstIterator::energy_computed() const –> bool

lower_neighbor_id(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbConstIterator) → int¶: C++: core::scoring::constraints::CstResNeighbConstIterator::lower_neighbor_id() const –> unsigned long

neighbor_id(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbConstIterator) → int¶: C++: core::scoring::constraints::CstResNeighbConstIterator::neighbor_id() const –> unsigned long

pre_increment(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbConstIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator¶: C++: core::scoring::constraints::CstResNeighbConstIterator::operator++() –> const class core::scoring::ResidueNeighborConstIterator &

residue_iterated_on(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbConstIterator) → int¶: C++: core::scoring::constraints::CstResNeighbConstIterator::residue_iterated_on() const –> unsigned long

retrieve_energy(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbConstIterator, : pyrosetta.rosetta.core.scoring.EMapVector) → None¶: C++: core::scoring::constraints::CstResNeighbConstIterator::retrieve_energy(class core::scoring::EMapVector &) const –> void

upper_neighbor_id(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbConstIterator) → int¶: C++: core::scoring::constraints::CstResNeighbConstIterator::upper_neighbor_id() const –> unsigned long

class pyrosetta.rosetta.core.scoring.constraints.CstResNeighbIterator¶

Bases: ResidueNeighborIterator

accumulate_energy(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbIterator, : pyrosetta.rosetta.core.scoring.EMapVector) → None¶: C++: core::scoring::constraints::CstResNeighbIterator::accumulate_energy(class core::scoring::EMapVector &) const –> void

assign(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbIterator, : pyrosetta.rosetta.core.scoring.ResidueNeighborIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator¶: C++: core::scoring::constraints::CstResNeighbIterator::operator=(const class core::scoring::ResidueNeighborIterator &) –> class core::scoring::ResidueNeighborIterator &

energy_computed(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbIterator) → bool¶: C++: core::scoring::constraints::CstResNeighbIterator::energy_computed() const –> bool

lower_neighbor_id(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbIterator) → int¶: C++: core::scoring::constraints::CstResNeighbIterator::lower_neighbor_id() const –> unsigned long

mark_energy_computed(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbIterator) → None¶: C++: core::scoring::constraints::CstResNeighbIterator::mark_energy_computed() –> void

mark_energy_uncomputed(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbIterator) → None¶: C++: core::scoring::constraints::CstResNeighbIterator::mark_energy_uncomputed() –> void

neighbor_id(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbIterator) → int¶: C++: core::scoring::constraints::CstResNeighbIterator::neighbor_id() const –> unsigned long

pre_increment(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator¶: C++: core::scoring::constraints::CstResNeighbIterator::operator++() –> const class core::scoring::ResidueNeighborIterator &

residue_iterated_on(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbIterator) → int¶: C++: core::scoring::constraints::CstResNeighbIterator::residue_iterated_on() const –> unsigned long

retrieve_energy(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbIterator, : pyrosetta.rosetta.core.scoring.EMapVector) → None¶: C++: core::scoring::constraints::CstResNeighbIterator::retrieve_energy(class core::scoring::EMapVector &) const –> void

save_energy(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbIterator, : pyrosetta.rosetta.core.scoring.EMapVector) → None¶: C++: core::scoring::constraints::CstResNeighbIterator::save_energy(const class core::scoring::EMapVector &) –> void

upper_neighbor_id(self: pyrosetta.rosetta.core.scoring.constraints.CstResNeighbIterator) → int¶: C++: core::scoring::constraints::CstResNeighbIterator::upper_neighbor_id() const –> unsigned long

class pyrosetta.rosetta.core.scoring.constraints.DOF_Constraint¶

Bases: pybind11_object

This isn’t quite a standard constraint since it acts on DOF’s directly: rather than on XYZ coordinates.

All DOF_Constraints are expected to be immutable once created, meaning their internal data (state) should not change over their lifetime. This allows DOF_Constraints to be shared between copies of Poses (e.g. in Monte Carlo), and is important for both speed (with thousands of contraints) and correctness.

DOF_Constraints are currently unsupported – they are never evaluated if you put them into a Pose.

dfunc(self: pyrosetta.rosetta.core.scoring.constraints.DOF_Constraint, val: float) → float¶

Returns the func::Function Derivative

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

dof_id(self: pyrosetta.rosetta.core.scoring.constraints.DOF_Constraint) → pyrosetta.rosetta.core.id.DOF_ID¶

Returns the ScoreType

C++: core::scoring::constraints::DOF_Constraint::dof_id() const –> const class core::id::DOF_ID &

func(self: pyrosetta.rosetta.core.scoring.constraints.DOF_Constraint, val: float) → float¶

Returns the func::Function

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

score_type(self: pyrosetta.rosetta.core.scoring.constraints.DOF_Constraint) → pyrosetta.rosetta.core.scoring.ScoreType¶

Returns the ScoreType

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

show(self: pyrosetta.rosetta.core.scoring.constraints.DOF_Constraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::DOF_Constraint::show(std::ostream &) const –> void

class pyrosetta.rosetta.core.scoring.constraints.DihedralConstraint¶

Bases: Constraint

constraint on dihedral angle formed by 4 points

atom(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraint, n: int) → pyrosetta.rosetta.core.id.AtomID¶: C++: core::scoring::constraints::DihedralConstraint::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.DihedralConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶

Perform a deep clone by cloning the func_ pointer held by this %DihedralConstraint

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

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
dist(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraint, xyz: core::scoring::func::XYZ_Func) -> float

C++: core::scoring::constraints::DihedralConstraint::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.DihedralConstraint, 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::DihedralConstraint::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.DihedralConstraint) → pyrosetta.rosetta.core.scoring.func.Func¶: C++: core::scoring::constraints::DihedralConstraint::get_func() const –> const class core::scoring::func::Func &

natoms(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraint) → int¶: C++: core::scoring::constraints::DihedralConstraint::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.DihedralConstraint, in: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: pyrosetta.rosetta.core.scoring.func.FuncFactory) → None¶: C++: core::scoring::constraints::DihedralConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::DihedralConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)¶

Overloaded function.

remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint
remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraint, 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::DihedralConstraint::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.

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.DihedralConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::DihedralConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraint, xyz1: pyrosetta.rosetta.numeric.xyzVector_double_t, xyz2: pyrosetta.rosetta.numeric.xyzVector_double_t, xyz3: pyrosetta.rosetta.numeric.xyzVector_double_t, xyz4: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

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

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

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

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

C++: core::scoring::constraints::DihedralConstraint::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.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.DihedralConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::DihedralConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::constraints::DihedralConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)¶

Overloaded function.

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

C++: core::scoring::constraints::DihedralConstraint::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.DihedralConstraint) → str¶: C++: core::scoring::constraints::DihedralConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.DihedralConstraintCreator¶

Bases: ConstraintCreator

Constraint creator for the DihedralConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.DihedralConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.DihedralConstraintCreator¶: C++: core::scoring::constraints::DihedralConstraintCreator::operator=(const class core::scoring::constraints::DihedralConstraintCreator &) –> class core::scoring::constraints::DihedralConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::DihedralConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraintCreator) → str¶: C++: core::scoring::constraints::DihedralConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraint¶

Bases: Constraint

constraint on dihedral angle formed by 4 points

atom(self: pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraint, n: int) → pyrosetta.rosetta.core.id.AtomID¶: C++: core::scoring::constraints::DihedralPairConstraint::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.DihedralPairConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::DihedralPairConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dihedral_diff(self: pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraint, X1: pyrosetta.rosetta.numeric.xyzVector_double_t, X2: pyrosetta.rosetta.numeric.xyzVector_double_t, X3: pyrosetta.rosetta.numeric.xyzVector_double_t, X4: pyrosetta.rosetta.numeric.xyzVector_double_t, Y1: pyrosetta.rosetta.numeric.xyzVector_double_t, Y2: pyrosetta.rosetta.numeric.xyzVector_double_t, Y3: pyrosetta.rosetta.numeric.xyzVector_double_t, Y4: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: core::scoring::constraints::DihedralPairConstraint::dihedral_diff(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) const –> double

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
dist(self: pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraint, xyz: core::scoring::func::XYZ_Func) -> float

C++: core::scoring::constraints::DihedralPairConstraint::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.DihedralPairConstraint, 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::DihedralPairConstraint::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.DihedralPairConstraint) → int¶: C++: core::scoring::constraints::DihedralPairConstraint::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.DihedralPairConstraint, in: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: pyrosetta.rosetta.core.scoring.func.FuncFactory) → None¶: C++: core::scoring::constraints::DihedralPairConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::DihedralPairConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)¶

Overloaded function.

remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint
remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraint, 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::DihedralPairConstraint::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.

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.DihedralPairConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::DihedralPairConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraint, X1: pyrosetta.rosetta.numeric.xyzVector_double_t, X2: pyrosetta.rosetta.numeric.xyzVector_double_t, X3: pyrosetta.rosetta.numeric.xyzVector_double_t, X4: pyrosetta.rosetta.numeric.xyzVector_double_t, Y1: pyrosetta.rosetta.numeric.xyzVector_double_t, Y2: pyrosetta.rosetta.numeric.xyzVector_double_t, Y3: pyrosetta.rosetta.numeric.xyzVector_double_t, Y4: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

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

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

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

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

C++: core::scoring::constraints::DihedralPairConstraint::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.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.DihedralPairConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::DihedralPairConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraint, : pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::constraints::DihedralPairConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)¶

Overloaded function.

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

C++: core::scoring::constraints::DihedralPairConstraint::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.DihedralPairConstraint) → str¶: C++: core::scoring::constraints::DihedralPairConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraintCreator¶

Bases: ConstraintCreator

Constraint creator for DihedralPairConstraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraintCreator¶: C++: core::scoring::constraints::DihedralPairConstraintCreator::operator=(const class core::scoring::constraints::DihedralPairConstraintCreator &) –> class core::scoring::constraints::DihedralPairConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::DihedralPairConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.DihedralPairConstraintCreator) → str¶: C++: core::scoring::constraints::DihedralPairConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.DistancePairConstraint¶

Bases: Constraint

constraint on CA distance

atom(self: pyrosetta.rosetta.core.scoring.constraints.DistancePairConstraint, n: int) → pyrosetta.rosetta.core.id.AtomID¶: C++: core::scoring::constraints::DistancePairConstraint::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.DistancePairConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::DistancePairConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.DistancePairConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
dist(self: pyrosetta.rosetta.core.scoring.constraints.DistancePairConstraint, xyz: core::scoring::func::XYZ_Func) -> float

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

distance_diff(self: pyrosetta.rosetta.core.scoring.constraints.DistancePairConstraint, X1: pyrosetta.rosetta.numeric.xyzVector_double_t, X2: pyrosetta.rosetta.numeric.xyzVector_double_t, Y1: pyrosetta.rosetta.numeric.xyzVector_double_t, Y2: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: core::scoring::constraints::DistancePairConstraint::distance_diff(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) 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.DistancePairConstraint, 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::DistancePairConstraint::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.DistancePairConstraint) → int¶: C++: core::scoring::constraints::DistancePairConstraint::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.DistancePairConstraint, in: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: pyrosetta.rosetta.core.scoring.func.FuncFactory) → None¶: C++: core::scoring::constraints::DistancePairConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.DistancePairConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::DistancePairConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)¶

Overloaded function.

remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.DistancePairConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint
remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.DistancePairConstraint, 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::DistancePairConstraint::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.

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.DistancePairConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::DistancePairConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.DistancePairConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.DistancePairConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.DistancePairConstraint, X1: pyrosetta.rosetta.numeric.xyzVector_double_t, X2: pyrosetta.rosetta.numeric.xyzVector_double_t, Y1: pyrosetta.rosetta.numeric.xyzVector_double_t, Y2: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

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

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

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

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

C++: core::scoring::constraints::DistancePairConstraint::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.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.DistancePairConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::DistancePairConstraint::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.

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

C++: core::scoring::constraints::DistancePairConstraint::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.DistancePairConstraint) → str¶: C++: core::scoring::constraints::DistancePairConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.FabConstraint¶

Bases: MultiConstraint

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 &

calc_penalty_vec(self: pyrosetta.rosetta.core.scoring.constraints.FabConstraint, start_res: int, stop_res: int, res1: pyrosetta.rosetta.utility.vector1_unsigned_long, res2: pyrosetta.rosetta.utility.vector1_unsigned_long) → pyrosetta.rosetta.utility.vector1_double¶: C++: core::scoring::constraints::FabConstraint::calc_penalty_vec(unsigned long, unsigned long, class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> class utility::vector1<double, class std::allocator<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.FabConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::FabConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
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.MultiConstraint) → pyrosetta.rosetta.core.scoring.constraints.MultiConstraint¶: C++: core::scoring::constraints::MultiConstraint::empty_clone() const –> class std::shared_ptr<class core::scoring::constraints::MultiConstraint>

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, 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::MultiConstraint::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 &

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

pose_res_no(self: pyrosetta.rosetta.core.scoring.constraints.FabConstraint, pose: pyrosetta.rosetta.core.pose.Pose, tempres: str) → int¶: C++: core::scoring::constraints::FabConstraint::pose_res_no(const class core::pose::Pose &, std::string) –> 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.FabConstraint, data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: pyrosetta.rosetta.core.scoring.func.FuncFactory) → None¶

read in constraint definition

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

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::MultiConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)¶

Overloaded function.

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
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.FabConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::FabConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, 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::MultiConstraint::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_csts(self: pyrosetta.rosetta.core.scoring.constraints.FabConstraint, pose: pyrosetta.rosetta.core.pose.Pose, res1: pyrosetta.rosetta.utility.vector1_unsigned_long, res2: pyrosetta.rosetta.utility.vector1_unsigned_long, antchains: str) → None¶: C++: core::scoring::constraints::FabConstraint::setup_csts(const class core::pose::Pose &, class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class utility::vector1<unsigned long, class std::allocator<unsigned long> >, std::string) –> 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.FabConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::FabConstraint::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.

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

C++: core::scoring::constraints::MultiConstraint::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.FabConstraint) → str¶: C++: core::scoring::constraints::FabConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.FabConstraintCreator¶

Bases: ConstraintCreator

Constraint creator for the FabConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.FabConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.FabConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.FabConstraintCreator¶: C++: core::scoring::constraints::FabConstraintCreator::operator=(const class core::scoring::constraints::FabConstraintCreator &) –> class core::scoring::constraints::FabConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.FabConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::FabConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.FabConstraintCreator) → str¶: C++: core::scoring::constraints::FabConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.KofNConstraint¶

Bases: MultiConstraint

active_constraints(self: pyrosetta.rosetta.core.scoring.constraints.KofNConstraint) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t¶: C++: core::scoring::constraints::KofNConstraint::active_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> > >

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.KofNConstraint, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) → float¶: C++: core::scoring::constraints::KofNConstraint::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.KofNConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::KofNConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
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.KofNConstraint) → pyrosetta.rosetta.core.scoring.constraints.MultiConstraint¶: C++: core::scoring::constraints::KofNConstraint::empty_clone() const –> class std::shared_ptr<class core::scoring::constraints::MultiConstraint>

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.KofNConstraint, 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::KofNConstraint::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

getK(self: pyrosetta.rosetta.core.scoring.constraints.KofNConstraint) → int¶: C++: core::scoring::constraints::KofNConstraint::getK() const –> unsigned long

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.KofNConstraint) → None¶: C++: core::scoring::constraints::KofNConstraint::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.KofNConstraint, data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: pyrosetta.rosetta.core.scoring.func.FuncFactory) → None¶

read in constraint defiinition

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

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.KofNConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::KofNConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)¶

Overloaded function.

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
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.KofNConstraint, rhs: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::KofNConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(self: pyrosetta.rosetta.core.scoring.constraints.KofNConstraint, 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::KofNConstraint::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 &

setK(self: pyrosetta.rosetta.core.scoring.constraints.KofNConstraint, K: int) → None¶: C++: core::scoring::constraints::KofNConstraint::setK(unsigned long) –> void

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.KofNConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::KofNConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.KofNConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::constraints::KofNConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)¶

Overloaded function.

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

C++: core::scoring::constraints::KofNConstraint::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.KofNConstraint) → str¶: C++: core::scoring::constraints::KofNConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.KofNConstraintCreator¶

Bases: ConstraintCreator

Constraint creator for the KofNConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.KofNConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.KofNConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.KofNConstraintCreator¶: C++: core::scoring::constraints::KofNConstraintCreator::operator=(const class core::scoring::constraints::KofNConstraintCreator &) –> class core::scoring::constraints::KofNConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.KofNConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::KofNConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.KofNConstraintCreator) → str¶: C++: core::scoring::constraints::KofNConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint¶

Bases: Constraint

atom(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint, n: int) → pyrosetta.rosetta.core.id.AtomID¶: C++: core::scoring::constraints::LocalCoordinateConstraint::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.LocalCoordinateConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::LocalCoordinateConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
dist(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint, xyz: core::scoring::func::XYZ_Func) -> float

C++: core::scoring::constraints::LocalCoordinateConstraint::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.LocalCoordinateConstraint, 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::LocalCoordinateConstraint::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.LocalCoordinateConstraint) → int¶: C++: core::scoring::constraints::LocalCoordinateConstraint::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.LocalCoordinateConstraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.func.FuncFactory) → None¶: C++: core::scoring::constraints::LocalCoordinateConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::LocalCoordinateConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)¶

Overloaded function.

remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint
remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint, 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::LocalCoordinateConstraint::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.

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.LocalCoordinateConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::LocalCoordinateConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint, xyz: pyrosetta.rosetta.numeric.xyzVector_double_t, s1: pyrosetta.rosetta.numeric.xyzVector_double_t, s2: pyrosetta.rosetta.numeric.xyzVector_double_t, s3: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

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

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

C++: core::scoring::constraints::LocalCoordinateConstraint::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_fixed_stub(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint, new_stub: pyrosetta.rosetta.core.id.StubID) → None¶: C++: core::scoring::constraints::LocalCoordinateConstraint::set_fixed_stub(class core::id::StubID) –> void

set_xyz_target(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint, xyz_in: pyrosetta.rosetta.numeric.xyzVector_double_t, local_frame_pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::constraints::LocalCoordinateConstraint::set_xyz_target(const class numeric::xyzVector<double> &, const class core::pose::Pose &) –> 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.LocalCoordinateConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::LocalCoordinateConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::constraints::LocalCoordinateConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)¶

Overloaded function.

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

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

steal_def(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint, : pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::constraints::LocalCoordinateConstraint::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.LocalCoordinateConstraint) → str¶: C++: core::scoring::constraints::LocalCoordinateConstraint::type() const –> std::string

xyz_target(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraint, local_frame_pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: core::scoring::constraints::LocalCoordinateConstraint::xyz_target(const class core::pose::Pose &) const –> class numeric::xyzVector<double>

class pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraintCreator¶

Bases: ConstraintCreator

Constraint creator for the LocalCoordinateConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraintCreator¶: C++: core::scoring::constraints::LocalCoordinateConstraintCreator::operator=(const class core::scoring::constraints::LocalCoordinateConstraintCreator &) –> class core::scoring::constraints::LocalCoordinateConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::LocalCoordinateConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.LocalCoordinateConstraintCreator) → str¶: C++: core::scoring::constraints::LocalCoordinateConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.MembraneSpanConstraint¶

Bases: Constraint

This class favors a particular residue identity at a particular position by reducing its res_type energy.

atom(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanConstraint, : int) → pyrosetta.rosetta.core.id.AtomID¶: C++: core::scoring::constraints::MembraneSpanConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

calc_score(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanConstraint) → float¶: C++: core::scoring::constraints::MembraneSpanConstraint::calc_score() const –> double

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.MembraneSpanConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::MembraneSpanConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
dist(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanConstraint, xyz: core::scoring::func::XYZ_Func) -> float

Return 1.0 if constraint will get a bonus, 0.0 if not

C++: core::scoring::constraints::MembraneSpanConstraint::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.MembraneSpanConstraint, 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::MembraneSpanConstraint::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.MembraneSpanConstraint) → int¶: C++: core::scoring::constraints::MembraneSpanConstraint::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.MembraneSpanConstraint, : pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::MembraneSpanConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)¶

Overloaded function.

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

C++: core::scoring::constraints::MembraneSpanConstraint::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.MembraneSpanConstraint) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: core::scoring::constraints::MembraneSpanConstraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::MembraneSpanConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanConstraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

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

score_res_z(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanConstraint, z: float) → float¶: C++: core::scoring::constraints::MembraneSpanConstraint::score_res_z(double) 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.MembraneSpanConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::MembraneSpanConstraint::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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int
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.MembraneSpanTermZConstraint¶

Bases: Constraint

This class favors a particular residue identity at a particular position by reducing its res_type energy.

atom(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanTermZConstraint, : int) → pyrosetta.rosetta.core.id.AtomID¶: C++: core::scoring::constraints::MembraneSpanTermZConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

calc_score(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanTermZConstraint) → float¶: C++: core::scoring::constraints::MembraneSpanTermZConstraint::calc_score() const –> double

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.MembraneSpanTermZConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::MembraneSpanTermZConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanTermZConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
dist(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanTermZConstraint, xyz: core::scoring::func::XYZ_Func) -> float

Return 1.0 if constraint will get a bonus, 0.0 if not

C++: core::scoring::constraints::MembraneSpanTermZConstraint::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.MembraneSpanTermZConstraint, 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::MembraneSpanTermZConstraint::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.MembraneSpanTermZConstraint) → int¶: C++: core::scoring::constraints::MembraneSpanTermZConstraint::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.MembraneSpanTermZConstraint, : pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::MembraneSpanTermZConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)¶

Overloaded function.

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

C++: core::scoring::constraints::MembraneSpanTermZConstraint::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.MembraneSpanTermZConstraint) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: core::scoring::constraints::MembraneSpanTermZConstraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanTermZConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::MembraneSpanTermZConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanTermZConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanTermZConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanTermZConstraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

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

score_delta(self: pyrosetta.rosetta.core.scoring.constraints.MembraneSpanTermZConstraint, a: float, b: float) → float¶: C++: core::scoring::constraints::MembraneSpanTermZConstraint::score_delta(double, double) 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.MembraneSpanTermZConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::MembraneSpanTermZConstraint::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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int
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.MultiConstraint¶

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

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.MultiConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶

Creates a deep copy of this %MultiConstaint, cloning all constraints that it holds.

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

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
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.MultiConstraint) → pyrosetta.rosetta.core.scoring.constraints.MultiConstraint¶: C++: core::scoring::constraints::MultiConstraint::empty_clone() const –> class std::shared_ptr<class core::scoring::constraints::MultiConstraint>

fill_f1_f2(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, 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::MultiConstraint::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 &

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.MultiConstraint, 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::MultiConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::MultiConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)¶

Overloaded function.

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
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.MultiConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::MultiConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, 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::MultiConstraint::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.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.

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

C++: core::scoring::constraints::MultiConstraint::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.MultiConstraint) → str¶: C++: core::scoring::constraints::MultiConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.MultiConstraintCreator¶

Bases: ConstraintCreator

Constraint creator for the MultiConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.MultiConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.MultiConstraintCreator¶: C++: core::scoring::constraints::MultiConstraintCreator::operator=(const class core::scoring::constraints::MultiConstraintCreator &) –> class core::scoring::constraints::MultiConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::MultiConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraintCreator) → str¶: C++: core::scoring::constraints::MultiConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraint¶

Bases: AngleConstraint

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.NamedAngleConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::NamedAngleConstraint::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.

dist(self: pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
dist(self: pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraint, xyz: core::scoring::func::XYZ_Func) -> float

C++: core::scoring::constraints::NamedAngleConstraint::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.NamedAngleConstraint, in: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: pyrosetta.rosetta.core.scoring.func.FuncFactory) → None¶: C++: core::scoring::constraints::NamedAngleConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

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

This overrride updates the sequence numbering but not the atom names.

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

remapped_clone(*args, **kwargs)¶

Overloaded function.

remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint
remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraint, 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::NamedAngleConstraint::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.

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.NamedAngleConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::NamedAngleConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraint, xyz: core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::NamedAngleConstraint::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.NamedAngleConstraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: core::scoring::constraints::NamedAngleConstraint::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.NamedAngleConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::constraints::NamedAngleConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_def_nopose(self: pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::NamedAngleConstraint::show_def_nopose(std::ostream &) const –> void

show_violations(*args, **kwargs)¶

Overloaded function.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AngleConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int
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.NamedAngleConstraint) → str¶: C++: core::scoring::constraints::NamedAngleConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraintCreator¶

Bases: ConstraintCreator

Constraint creator for the NamedAngleConstraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraintCreator¶: C++: core::scoring::constraints::NamedAngleConstraintCreator::operator=(const class core::scoring::constraints::NamedAngleConstraintCreator &) –> class core::scoring::constraints::NamedAngleConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::NamedAngleConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.NamedAngleConstraintCreator) → str¶: C++: core::scoring::constraints::NamedAngleConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.NamedAtomPairConstraint¶

Bases: AtomPairConstraint

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(self: pyrosetta.rosetta.core.scoring.constraints.NamedAtomPairConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::NamedAtomPairConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

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

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.NamedAtomPairConstraint, in: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: pyrosetta.rosetta.core.scoring.func.FuncFactory) → None¶: C++: core::scoring::constraints::NamedAtomPairConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

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

This override updates the sequence numbering but not the atom names.

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

remapped_clone(*args, **kwargs)¶

Overloaded function.

remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.NamedAtomPairConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint
remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.NamedAtomPairConstraint, 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::NamedAtomPairConstraint::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.

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.NamedAtomPairConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::NamedAtomPairConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
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

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

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.NamedAtomPairConstraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: core::scoring::constraints::NamedAtomPairConstraint::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.NamedAtomPairConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::constraints::NamedAtomPairConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_def_nopose(self: pyrosetta.rosetta.core.scoring.constraints.NamedAtomPairConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::NamedAtomPairConstraint::show_def_nopose(std::ostream &) const –> void

show_violations(*args, **kwargs)¶

Overloaded function.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int
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.NamedAtomPairConstraint) → str¶: C++: core::scoring::constraints::NamedAtomPairConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.NamedAtomPairConstraintCreator¶

Bases: ConstraintCreator

Constraint creator for the NamedAtomPairConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.NamedAtomPairConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.NamedAtomPairConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.NamedAtomPairConstraintCreator¶: C++: core::scoring::constraints::NamedAtomPairConstraintCreator::operator=(const class core::scoring::constraints::NamedAtomPairConstraintCreator &) –> class core::scoring::constraints::NamedAtomPairConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.NamedAtomPairConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::NamedAtomPairConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.NamedAtomPairConstraintCreator) → str¶: C++: core::scoring::constraints::NamedAtomPairConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.NamedDihedralConstraint¶

Bases: DihedralConstraint

atom(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraint, n: int) → pyrosetta.rosetta.core.id.AtomID¶: C++: core::scoring::constraints::DihedralConstraint::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.NamedDihedralConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::NamedDihedralConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.NamedDihedralConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
dist(self: pyrosetta.rosetta.core.scoring.constraints.NamedDihedralConstraint, xyz: core::scoring::func::XYZ_Func) -> float

C++: core::scoring::constraints::NamedDihedralConstraint::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.DihedralConstraint, 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::DihedralConstraint::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.DihedralConstraint) → pyrosetta.rosetta.core.scoring.func.Func¶: C++: core::scoring::constraints::DihedralConstraint::get_func() const –> const class core::scoring::func::Func &

natoms(self: pyrosetta.rosetta.core.scoring.constraints.DihedralConstraint) → int¶: C++: core::scoring::constraints::DihedralConstraint::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.NamedDihedralConstraint, in: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: pyrosetta.rosetta.core.scoring.func.FuncFactory) → None¶: C++: core::scoring::constraints::NamedDihedralConstraint::read_def(std::istream &, const class core::pose::Pose &, const class core::scoring::func::FuncFactory &) –> void

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

This overrride updates the sequence numbering but not the atom names.

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

remapped_clone(*args, **kwargs)¶

Overloaded function.

remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.NamedDihedralConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint
remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.NamedDihedralConstraint, 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::NamedDihedralConstraint::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.

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.NamedDihedralConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::NamedDihedralConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.NamedDihedralConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.NamedDihedralConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.NamedDihedralConstraint, xyz: core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::NamedDihedralConstraint::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.DihedralConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::DihedralConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.NamedDihedralConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::constraints::NamedDihedralConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_def_nopose(self: pyrosetta.rosetta.core.scoring.constraints.NamedDihedralConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::NamedDihedralConstraint::show_def_nopose(std::ostream &) const –> void

show_violations(*args, **kwargs)¶

Overloaded function.

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

C++: core::scoring::constraints::DihedralConstraint::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.NamedDihedralConstraint) → str¶: C++: core::scoring::constraints::NamedDihedralConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.NonResidueTypeConstraint¶

Bases: Constraint

This class favors a particular residue identity at a particular position by reducing its res_type energy.

atom(self: pyrosetta.rosetta.core.scoring.constraints.NonResidueTypeConstraint, : int) → pyrosetta.rosetta.core.id.AtomID¶: C++: core::scoring::constraints::NonResidueTypeConstraint::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.NonResidueTypeConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::NonResidueTypeConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.NonResidueTypeConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
dist(self: pyrosetta.rosetta.core.scoring.constraints.NonResidueTypeConstraint, xyz: core::scoring::func::XYZ_Func) -> float

Return 1.0 if constraint will get a penalty, 0.0 if not

C++: core::scoring::constraints::NonResidueTypeConstraint::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.NonResidueTypeConstraint, 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::NonResidueTypeConstraint::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.NonResidueTypeConstraint) → int¶: C++: core::scoring::constraints::NonResidueTypeConstraint::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.NonResidueTypeConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::NonResidueTypeConstraint::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.NonResidueTypeConstraint) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: core::scoring::constraints::NonResidueTypeConstraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.NonResidueTypeConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::NonResidueTypeConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.NonResidueTypeConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.NonResidueTypeConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.NonResidueTypeConstraint, xyz_func: core::scoring::func::XYZ_Func, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::NonResidueTypeConstraint::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.NonResidueTypeConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::NonResidueTypeConstraint::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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int
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.Obsolet_NamedAtomPairConstraint¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint, : pyrosetta.rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint) → pyrosetta.rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint¶: C++: core::scoring::constraints::Obsolet_NamedAtomPairConstraint::operator=(const class core::scoring::constraints::Obsolet_NamedAtomPairConstraint &) –> class core::scoring::constraints::Obsolet_NamedAtomPairConstraint &

atom1(self: pyrosetta.rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint) → pyrosetta.rosetta.core.id.NamedAtomID¶: C++: core::scoring::constraints::Obsolet_NamedAtomPairConstraint::atom1() –> const class core::id::NamedAtomID &

atom2(self: pyrosetta.rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint) → pyrosetta.rosetta.core.id.NamedAtomID¶: C++: core::scoring::constraints::Obsolet_NamedAtomPairConstraint::atom2() –> const class core::id::NamedAtomID &

mapto(*args, **kwargs)¶

Overloaded function.

mapto(self: pyrosetta.rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint, : pyrosetta.rosetta.core.id.SequenceMapping, : pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint

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

mapto(self: pyrosetta.rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint, : pyrosetta.rosetta.core.id.SequenceMapping) -> pyrosetta.rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint

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

mapto(self: pyrosetta.rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint, : pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.AtomPairConstraint

C++: core::scoring::constraints::Obsolet_NamedAtomPairConstraint::mapto(const class core::pose::Pose &) const –> class std::shared_ptr<class core::scoring::constraints::AtomPairConstraint>

class pyrosetta.rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc¶

Bases: BoundFunc

a variant of the bound func that is periodic

assign(self: pyrosetta.rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc, : pyrosetta.rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc) → pyrosetta.rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc¶: C++: core::scoring::constraints::OffsetPeriodicBoundFunc::operator=(const class core::scoring::constraints::OffsetPeriodicBoundFunc &) –> class core::scoring::constraints::OffsetPeriodicBoundFunc &

clone(self: pyrosetta.rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc) → pyrosetta.rosetta.core.scoring.func.Func¶: C++: core::scoring::constraints::OffsetPeriodicBoundFunc::clone() const –> class std::shared_ptr<class core::scoring::func::Func>

dfunc(self: pyrosetta.rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc, x: float) → float¶: C++: core::scoring::constraints::OffsetPeriodicBoundFunc::dfunc(const double) const –> double

estimate_dfunc(*args, **kwargs)¶

Overloaded function.

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

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.OffsetPeriodicBoundFunc, x: float) → float¶: C++: core::scoring::constraints::OffsetPeriodicBoundFunc::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.OffsetPeriodicBoundFunc, : pyrosetta.rosetta.std.istream) → None¶: C++: core::scoring::constraints::OffsetPeriodicBoundFunc::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.OffsetPeriodicBoundFunc, rhs: pyrosetta.rosetta.core.scoring.func.Func) → bool¶: C++: core::scoring::constraints::OffsetPeriodicBoundFunc::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.OffsetPeriodicBoundFunc, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::OffsetPeriodicBoundFunc::show_definition(std::ostream &) const –> void

show_violations(*args, **kwargs)¶

Overloaded function.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc, out: pyrosetta.rosetta.std.ostream, x: float, verbose_level: int) -> int
show_violations(self: pyrosetta.rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc, out: pyrosetta.rosetta.std.ostream, x: float, verbose_level: int, threshold: float) -> int

C++: core::scoring::constraints::OffsetPeriodicBoundFunc::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.PeriodicBoundFunc¶

Bases: BoundFunc

a variant of the bound func that is periodic

assign(self: pyrosetta.rosetta.core.scoring.constraints.PeriodicBoundFunc, : pyrosetta.rosetta.core.scoring.constraints.PeriodicBoundFunc) → pyrosetta.rosetta.core.scoring.constraints.PeriodicBoundFunc¶: C++: core::scoring::constraints::PeriodicBoundFunc::operator=(const class core::scoring::constraints::PeriodicBoundFunc &) –> class core::scoring::constraints::PeriodicBoundFunc &

clone(self: pyrosetta.rosetta.core.scoring.constraints.PeriodicBoundFunc) → pyrosetta.rosetta.core.scoring.func.Func¶: C++: core::scoring::constraints::PeriodicBoundFunc::clone() const –> class std::shared_ptr<class core::scoring::func::Func>

dfunc(self: pyrosetta.rosetta.core.scoring.constraints.PeriodicBoundFunc, x: float) → float¶: C++: core::scoring::constraints::PeriodicBoundFunc::dfunc(const double) const –> double

estimate_dfunc(*args, **kwargs)¶

Overloaded function.

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

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.PeriodicBoundFunc, x: float) → float¶: C++: core::scoring::constraints::PeriodicBoundFunc::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.PeriodicBoundFunc, : pyrosetta.rosetta.std.istream) → None¶: C++: core::scoring::constraints::PeriodicBoundFunc::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.PeriodicBoundFunc, rhs: pyrosetta.rosetta.core.scoring.func.Func) → bool¶: C++: core::scoring::constraints::PeriodicBoundFunc::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.PeriodicBoundFunc, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::PeriodicBoundFunc::show_definition(std::ostream &) const –> void

show_violations(*args, **kwargs)¶

Overloaded function.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.PeriodicBoundFunc, out: pyrosetta.rosetta.std.ostream, x: float, verbose_level: int) -> int
show_violations(self: pyrosetta.rosetta.core.scoring.constraints.PeriodicBoundFunc, out: pyrosetta.rosetta.std.ostream, x: float, verbose_level: int, threshold: float) -> int

C++: core::scoring::constraints::PeriodicBoundFunc::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.RTConstraint¶

Bases: Constraint

atom(self: pyrosetta.rosetta.core.scoring.constraints.RTConstraint, n: int) → pyrosetta.rosetta.core.id.AtomID¶: C++: core::scoring::constraints::RTConstraint::atom(const unsigned long) const –> const class core::id::AtomID &

calculate_rt(self: pyrosetta.rosetta.core.scoring.constraints.RTConstraint, : core::scoring::func::XYZ_Func) → pyrosetta.rosetta.core.kinematics.RT¶

calculates the RT from stub1->stub2 at this instant

C++: core::scoring::constraints::RTConstraint::calculate_rt(const class core::scoring::func::XYZ_Func &) const –> class core::kinematics::RT

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.

clone(self: pyrosetta.rosetta.core.scoring.constraints.RTConstraint) -> 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::RTConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

clone(self: pyrosetta.rosetta.core.scoring.constraints.RTConstraint, : pyrosetta.rosetta.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::RTConstraint::clone(class std::shared_ptr<class core::scoring::func::Func>) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(self: pyrosetta.rosetta.core.scoring.constraints.RTConstraint, xyz: core::scoring::func::XYZ_Func) → float¶

return the raw “distance” before that distance is handed to the FUNC object

C++: core::scoring::constraints::RTConstraint::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.RTConstraint, 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::RTConstraint::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.RTConstraint) → pyrosetta.rosetta.core.scoring.func.Func¶: C++: core::scoring::constraints::RTConstraint::get_func() const –> const class core::scoring::func::Func &

natoms(self: pyrosetta.rosetta.core.scoring.constraints.RTConstraint) → int¶: C++: core::scoring::constraints::RTConstraint::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.

remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.RTConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.scoring.constraints.Constraint
remapped_clone(self: pyrosetta.rosetta.core.scoring.constraints.RTConstraint, 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::RTConstraint::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.

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.RTConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::RTConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(self: pyrosetta.rosetta.core.scoring.constraints.RTConstraint, 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::RTConstraint::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.RTConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::RTConstraint::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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int
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.RTConstraint) → str¶: C++: core::scoring::constraints::RTConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.ResidueConstraints¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.scoring.constraints.ResidueConstraints, : pyrosetta.rosetta.core.scoring.constraints.ResidueConstraints) → pyrosetta.rosetta.core.scoring.constraints.ResidueConstraints¶: C++: core::scoring::constraints::ResidueConstraints::operator=(const class core::scoring::constraints::ResidueConstraints &) –> class core::scoring::constraints::ResidueConstraints &

clear(self: pyrosetta.rosetta.core.scoring.constraints.ResidueConstraints) → None¶: C++: core::scoring::constraints::ResidueConstraints::clear() –> void

erase(self: pyrosetta.rosetta.core.scoring.constraints.ResidueConstraints, seqpos: int) → None¶: C++: core::scoring::constraints::ResidueConstraints::erase(const unsigned long) –> void

has(self: pyrosetta.rosetta.core.scoring.constraints.ResidueConstraints, seqpos: int) → bool¶: C++: core::scoring::constraints::ResidueConstraints::has(const unsigned long) –> bool

insert(self: pyrosetta.rosetta.core.scoring.constraints.ResidueConstraints, seqpos: int, cst: pyrosetta.rosetta.core.scoring.constraints.Constraints) → None¶: C++: core::scoring::constraints::ResidueConstraints::insert(const unsigned long, class std::shared_ptr<class core::scoring::constraints::Constraints>) –> void

size(self: pyrosetta.rosetta.core.scoring.constraints.ResidueConstraints) → int¶: C++: core::scoring::constraints::ResidueConstraints::size() const –> unsigned long

class pyrosetta.rosetta.core.scoring.constraints.ResidueCouplingConstraint¶

Bases: Constraint

This class favors a particular residue identity at two particular positions by adding the scaled tensor value to the energy map.

atom(self: pyrosetta.rosetta.core.scoring.constraints.ResidueCouplingConstraint, : int) → pyrosetta.rosetta.core.id.AtomID¶: C++: core::scoring::constraints::ResidueCouplingConstraint::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.ResidueCouplingConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::ResidueCouplingConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.ResidueCouplingConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
dist(self: pyrosetta.rosetta.core.scoring.constraints.ResidueCouplingConstraint, xyz: core::scoring::func::XYZ_Func) -> float

Return 1.0 if constraint will get a bonus/penalty, 0.0 if not

C++: core::scoring::constraints::ResidueCouplingConstraint::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.ResidueCouplingConstraint, 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::ResidueCouplingConstraint::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_alphabet(self: pyrosetta.rosetta.core.scoring.constraints.ResidueCouplingConstraint) → str¶: C++: core::scoring::constraints::ResidueCouplingConstraint::get_alphabet() const –> std::string

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.ResidueCouplingConstraint) → int¶: C++: core::scoring::constraints::ResidueCouplingConstraint::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.ResidueCouplingConstraint) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: core::scoring::constraints::ResidueCouplingConstraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.ResidueCouplingConstraint, : pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::ResidueCouplingConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.ResidueCouplingConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.ResidueCouplingConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.ResidueCouplingConstraint, xyz_func: core::scoring::func::XYZ_Func, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::ResidueCouplingConstraint::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_alphabet(self: pyrosetta.rosetta.core.scoring.constraints.ResidueCouplingConstraint, alphabet: str) → None¶: C++: core::scoring::constraints::ResidueCouplingConstraint::set_alphabet(const std::string &) –> 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.ResidueCouplingConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::ResidueCouplingConstraint::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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int
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.ResidueTypeConstraint¶

Bases: Constraint

This class favors a particular residue identity at a particular position by reducing its res_type energy.

atom(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeConstraint, : int) → pyrosetta.rosetta.core.id.AtomID¶: C++: core::scoring::constraints::ResidueTypeConstraint::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.ResidueTypeConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::ResidueTypeConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
dist(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeConstraint, xyz: core::scoring::func::XYZ_Func) -> float

Return 1.0 if constraint will get a bonus, 0.0 if not

C++: core::scoring::constraints::ResidueTypeConstraint::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.ResidueTypeConstraint, 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::ResidueTypeConstraint::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_favor_native_bonus(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeConstraint) → float¶: C++: core::scoring::constraints::ResidueTypeConstraint::get_favor_native_bonus() const –> double

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 &

get_rsd_type_name3(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeConstraint) → str¶: C++: core::scoring::constraints::ResidueTypeConstraint::get_rsd_type_name3() const –> std::string

natoms(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeConstraint) → int¶: C++: core::scoring::constraints::ResidueTypeConstraint::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.ResidueTypeConstraint, seqmap: pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::ResidueTypeConstraint::remap_resid(const class core::id::SequenceMapping &) const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

remapped_clone(*args, **kwargs)¶

Overloaded function.

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

C++: core::scoring::constraints::ResidueTypeConstraint::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.ResidueTypeConstraint) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: core::scoring::constraints::ResidueTypeConstraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeConstraint, other: pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::ResidueTypeConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeConstraint, xyz_func: core::scoring::func::XYZ_Func, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::ResidueTypeConstraint::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.ResidueTypeConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::ResidueTypeConstraint::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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int
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.ResidueTypeLinkingConstraint¶

Bases: Constraint

This class favors a particular residue identity at a particular position by reducing its res_type energy.

add_bonus_map_entry(*args, **kwargs)¶

Overloaded function.

add_bonus_map_entry(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, key: Tuple[pyrosetta.rosetta.core.chemical.AA, pyrosetta.rosetta.core.chemical.AA], bonus: float) -> None
add_bonus_map_entry(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, key: Tuple[pyrosetta.rosetta.core.chemical.AA, pyrosetta.rosetta.core.chemical.AA], bonus: float, overwrite: bool) -> None

Add a map entry to the current bonus_map_

C++: core::scoring::constraints::ResidueTypeLinkingConstraint::add_bonus_map_entry(struct std::pair<enum core::chemical::AA, enum core::chemical::AA>, double, bool) –> void

add_bonus_map_entry(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, aa1: pyrosetta.rosetta.core.chemical.AA, aa2: pyrosetta.rosetta.core.chemical.AA, bonus: float) -> None
add_bonus_map_entry(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, aa1: pyrosetta.rosetta.core.chemical.AA, aa2: pyrosetta.rosetta.core.chemical.AA, bonus: float, overwrite: bool) -> None

Add a map entry to the current bonus_map_

C++: core::scoring::constraints::ResidueTypeLinkingConstraint::add_bonus_map_entry(enum core::chemical::AA, enum core::chemical::AA, double, bool) –> void

add_bonus_map_entry(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, key: str, bonus: float) -> None
add_bonus_map_entry(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, key: str, bonus: float, overwrite: bool) -> None

Add a map entry to the current bonus_map_

C++: core::scoring::constraints::ResidueTypeLinkingConstraint::add_bonus_map_entry(std::string, double, bool) –> void

atom(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, : int) → pyrosetta.rosetta.core.id.AtomID¶: C++: core::scoring::constraints::ResidueTypeLinkingConstraint::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.ResidueTypeLinkingConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::ResidueTypeLinkingConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
dist(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, xyz: core::scoring::func::XYZ_Func) -> float

Return 1.0 if constraint will get a bonus/penalty, 0.0 if not

C++: core::scoring::constraints::ResidueTypeLinkingConstraint::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.ResidueTypeLinkingConstraint, 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::ResidueTypeLinkingConstraint::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_bonus_map(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint) → pyrosetta.rosetta.std.map_std_pair_core_chemical_AA_core_chemical_AA_t_double_std_less_std_pair_core_chemical_AA_core_chemical_AA_t_std_allocator_std_pair_const_std_pair_core_chemical_AA_core_chemical_AA_double_t¶: C++: core::scoring::constraints::ResidueTypeLinkingConstraint::get_bonus_map() –> const class std::map<struct std::pair<enum core::chemical::AA, enum core::chemical::AA>, double, struct std::less<struct std::pair<enum core::chemical::AA, enum core::chemical::AA> >, class std::allocator<struct std::pair<const struct std::pair<enum core::chemical::AA, enum core::chemical::AA>, double> > > &

get_default_bonus(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint) → float¶: C++: core::scoring::constraints::ResidueTypeLinkingConstraint::get_default_bonus() const –> double

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 &

get_seqpos1(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint) → int¶: C++: core::scoring::constraints::ResidueTypeLinkingConstraint::get_seqpos1() const –> unsigned long

get_seqpos2(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint) → int¶: C++: core::scoring::constraints::ResidueTypeLinkingConstraint::get_seqpos2() const –> unsigned long

natoms(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint) → int¶: C++: core::scoring::constraints::ResidueTypeLinkingConstraint::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.ResidueTypeLinkingConstraint) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: core::scoring::constraints::ResidueTypeLinkingConstraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, : pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::ResidueTypeLinkingConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, xyz_func: core::scoring::func::XYZ_Func, weights: pyrosetta.rosetta.core.scoring.EMapVector, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::ResidueTypeLinkingConstraint::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_bonus_map(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, bonus_map: pyrosetta.rosetta.std.map_std_pair_core_chemical_AA_core_chemical_AA_t_double_std_less_std_pair_core_chemical_AA_core_chemical_AA_t_std_allocator_std_pair_const_std_pair_core_chemical_AA_core_chemical_AA_double_t) → None¶: C++: core::scoring::constraints::ResidueTypeLinkingConstraint::set_bonus_map(const class std::map<struct std::pair<enum core::chemical::AA, enum core::chemical::AA>, double, struct std::less<struct std::pair<enum core::chemical::AA, enum core::chemical::AA> >, class std::allocator<struct std::pair<const struct std::pair<enum core::chemical::AA, enum core::chemical::AA>, double> > > &) –> void

set_default_bonus(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, : float) → None¶: C++: core::scoring::constraints::ResidueTypeLinkingConstraint::set_default_bonus(double) –> void

set_seqpos1(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, seqpos1: int) → None¶: C++: core::scoring::constraints::ResidueTypeLinkingConstraint::set_seqpos1(unsigned long) –> void

set_seqpos2(self: pyrosetta.rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, seqpos2: int) → None¶: C++: core::scoring::constraints::ResidueTypeLinkingConstraint::set_seqpos2(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.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.ResidueTypeLinkingConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::ResidueTypeLinkingConstraint::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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int
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.SequenceProfileConstraint¶

Bases: Constraint

atom(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint, : int) → pyrosetta.rosetta.core.id.AtomID¶: C++: core::scoring::constraints::SequenceProfileConstraint::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.SequenceProfileConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::SequenceProfileConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
dist(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint, aa: pyrosetta.rosetta.core.chemical.AA) -> float

C++: core::scoring::constraints::SequenceProfileConstraint::dist(enum core::chemical::AA) const –> double

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

C++: core::scoring::constraints::SequenceProfileConstraint::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.SequenceProfileConstraint, : pyrosetta.rosetta.core.id.AtomID, : 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::SequenceProfileConstraint::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.SequenceProfileConstraint) → int¶: C++: core::scoring::constraints::SequenceProfileConstraint::natoms() const –> unsigned long

profile_mapping(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint) → pyrosetta.rosetta.core.id.SequenceMapping¶: C++: core::scoring::constraints::SequenceProfileConstraint::profile_mapping() const –> class std::shared_ptr<const class core::id::SequenceMapping>

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.SequenceProfileConstraint, : pyrosetta.rosetta.std.istream, : pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.scoring.func.FuncFactory) → None¶

used by ConstraintIO and ConstraintFactory to construct this constraint from a input file stream (constraint file)

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

remap_resid(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint, : pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::SequenceProfileConstraint::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.SequenceProfileConstraint, src: pyrosetta.rosetta.core.pose.Pose, dest: pyrosetta.rosetta.core.pose.Pose, map: pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::SequenceProfileConstraint::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.SequenceProfileConstraint) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: core::scoring::constraints::SequenceProfileConstraint::residues() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

same_type_as_me(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint, : pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::SequenceProfileConstraint::same_type_as_me(const class core::scoring::constraints::Constraint &) const –> bool

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint, pose: pyrosetta.rosetta.core.pose.Pose) -> float
score(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint, : core::scoring::func::XYZ_Func, : pyrosetta.rosetta.core.scoring.EMapVector, : pyrosetta.rosetta.core.scoring.EMapVector) -> None

C++: core::scoring::constraints::SequenceProfileConstraint::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(*args, **kwargs)¶

Overloaded function.

seqpos(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint) -> int

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

seqpos(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint, seqpos: int) -> None

C++: core::scoring::constraints::SequenceProfileConstraint::seqpos(unsigned long) –> void

sequence_profile(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint) → core::sequence::SequenceProfile¶: C++: core::scoring::constraints::SequenceProfileConstraint::sequence_profile() const –> class std::shared_ptr<const class core::sequence::SequenceProfile>

set_sequence_profile(*args, **kwargs)¶

Overloaded function.

set_sequence_profile(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint, profile: core::sequence::SequenceProfile) -> None
set_sequence_profile(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint, profile: core::sequence::SequenceProfile, mapping: pyrosetta.rosetta.core.id.SequenceMapping) -> None

C++: core::scoring::constraints::SequenceProfileConstraint::set_sequence_profile(class std::shared_ptr<const class core::sequence::SequenceProfile>, class std::shared_ptr<const class core::id::SequenceMapping>) –> 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.SequenceProfileConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::SequenceProfileConstraint::show(std::ostream &) const –> void

show_def(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint, : pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::constraints::SequenceProfileConstraint::show_def(std::ostream &, const class core::pose::Pose &) const –> void

show_violations(*args, **kwargs)¶

Overloaded function.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.Constraint, out: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose, : int) -> int
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.SequenceProfileConstraint) → str¶: C++: core::scoring::constraints::SequenceProfileConstraint::type() const –> std::string

weight(*args, **kwargs)¶

Overloaded function.

weight(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint, w: float) -> None

C++: core::scoring::constraints::SequenceProfileConstraint::weight(const double) –> void

weight(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraint) -> float

C++: core::scoring::constraints::SequenceProfileConstraint::weight() const –> double

class pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraintCreator¶

Bases: ConstraintCreator

Constraint creator for the SequenceProfileConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraintCreator¶: C++: core::scoring::constraints::SequenceProfileConstraintCreator::operator=(const class core::scoring::constraints::SequenceProfileConstraintCreator &) –> class core::scoring::constraints::SequenceProfileConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::SequenceProfileConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.SequenceProfileConstraintCreator) → str¶: C++: core::scoring::constraints::SequenceProfileConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.SiteConstraint¶

Bases: AmbiguousConstraint

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.SiteConstraint) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::SiteConstraint::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
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.SiteConstraint, data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: pyrosetta.rosetta.core.scoring.func.FuncFactory) → None¶

read in constraint defiinition

C++: core::scoring::constraints::SiteConstraint::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.

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
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.SiteConstraint, : pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::SiteConstraint::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_csts(*args, **kwargs)¶

Overloaded function.

setup_csts(self: pyrosetta.rosetta.core.scoring.constraints.SiteConstraint, res: int, name: str, chain: str, pose: pyrosetta.rosetta.core.pose.Pose, func: pyrosetta.rosetta.core.scoring.func.Func) -> None

Sets up SiteConstaint between the residue of interest and a chain

C++: core::scoring::constraints::SiteConstraint::setup_csts(unsigned long, std::string, std::string, const class core::pose::Pose &, const class std::shared_ptr<class core::scoring::func::Func> &) –> void

setup_csts(self: pyrosetta.rosetta.core.scoring.constraints.SiteConstraint, res: int, name: str, residues: pyrosetta.rosetta.utility.vector1_bool, pose: pyrosetta.rosetta.core.pose.Pose, func: pyrosetta.rosetta.core.scoring.func.Func) -> None

Sets up SiteConstraint between the residue of interest and a subset of residues

C++: core::scoring::constraints::SiteConstraint::setup_csts(unsigned long, std::string, const class utility::vector1<bool, class std::allocator<bool> > &, const class core::pose::Pose &, const class std::shared_ptr<class core::scoring::func::Func> &) –> 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.SiteConstraint, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::SiteConstraint::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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int
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.SiteConstraint) → str¶: C++: core::scoring::constraints::SiteConstraint::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.SiteConstraintCreator¶

Bases: ConstraintCreator

Constraint creator for the SiteConstraint constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.SiteConstraintCreator, : pyrosetta.rosetta.core.scoring.constraints.SiteConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.SiteConstraintCreator¶: C++: core::scoring::constraints::SiteConstraintCreator::operator=(const class core::scoring::constraints::SiteConstraintCreator &) –> class core::scoring::constraints::SiteConstraintCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.SiteConstraintCreator) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::SiteConstraintCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.SiteConstraintCreator) → str¶: C++: core::scoring::constraints::SiteConstraintCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.SiteConstraintResidues¶

Bases: AmbiguousConstraint

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.SiteConstraintResidues) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::SiteConstraintResidues::clone() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

dist(*args, **kwargs)¶

Overloaded function.

dist(self: pyrosetta.rosetta.core.scoring.constraints.MultiConstraint, : pyrosetta.rosetta.core.pose.Pose) -> float
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.SiteConstraintResidues, data: pyrosetta.rosetta.std.istream, pose: pyrosetta.rosetta.core.pose.Pose, func_factory: pyrosetta.rosetta.core.scoring.func.FuncFactory) → None¶

read in constraint defiinition

C++: core::scoring::constraints::SiteConstraintResidues::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.

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
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.SiteConstraintResidues, : pyrosetta.rosetta.core.scoring.constraints.Constraint) → bool¶: C++: core::scoring::constraints::SiteConstraintResidues::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_csts(self: pyrosetta.rosetta.core.scoring.constraints.SiteConstraintResidues, res1: int, name: str, res2: int, res3: int, pose: pyrosetta.rosetta.core.pose.Pose, func: pyrosetta.rosetta.core.scoring.func.Func) → None¶: C++: core::scoring::constraints::SiteConstraintResidues::setup_csts(unsigned long, std::string, unsigned long, unsigned long, const class core::pose::Pose &, const class std::shared_ptr<class core::scoring::func::Func> &) –> 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.SiteConstraintResidues, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::constraints::SiteConstraintResidues::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.

show_violations(self: pyrosetta.rosetta.core.scoring.constraints.AmbiguousConstraint, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose_level: int) -> int
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.SiteConstraintResidues) → str¶: C++: core::scoring::constraints::SiteConstraintResidues::type() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.SiteConstraintResiduesCreator¶

Bases: ConstraintCreator

Constraint creator for the SiteConstraintResidues constraint

assign(self: pyrosetta.rosetta.core.scoring.constraints.SiteConstraintResiduesCreator, : pyrosetta.rosetta.core.scoring.constraints.SiteConstraintResiduesCreator) → pyrosetta.rosetta.core.scoring.constraints.SiteConstraintResiduesCreator¶: C++: core::scoring::constraints::SiteConstraintResiduesCreator::operator=(const class core::scoring::constraints::SiteConstraintResiduesCreator &) –> class core::scoring::constraints::SiteConstraintResiduesCreator &

create_constraint(self: pyrosetta.rosetta.core.scoring.constraints.SiteConstraintResiduesCreator) → pyrosetta.rosetta.core.scoring.constraints.Constraint¶: C++: core::scoring::constraints::SiteConstraintResiduesCreator::create_constraint() const –> class std::shared_ptr<class core::scoring::constraints::Constraint>

keyname(self: pyrosetta.rosetta.core.scoring.constraints.SiteConstraintResiduesCreator) → str¶: C++: core::scoring::constraints::SiteConstraintResiduesCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.scoring.constraints.XYZs¶

Bases: pybind11_object

property atom¶

property axis1¶

property axis2¶

pyrosetta.rosetta.core.scoring.constraints.add_constraints_from_cmdline(pose: pyrosetta.rosetta.core.pose.Pose, scorefxn_: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

/: add constraints if specified by user.

C++: core::scoring::constraints::add_constraints_from_cmdline(class core::pose::Pose &, class core::scoring::ScoreFunction &) –> void

pyrosetta.rosetta.core.scoring.constraints.add_constraints_from_cmdline_to_pose(pose: pyrosetta.rosetta.core.pose.Pose) → None¶

/: add constraints if specified by user.

C++: core::scoring::constraints::add_constraints_from_cmdline_to_pose(class core::pose::Pose &) –> void

pyrosetta.rosetta.core.scoring.constraints.add_constraints_from_cmdline_to_scorefxn(scorefxn_: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

/: add constraints if specified by user.

C++: core::scoring::constraints::add_constraints_from_cmdline_to_scorefxn(class core::scoring::ScoreFunction &) –> void

pyrosetta.rosetta.core.scoring.constraints.add_coordinate_constraints(*args, **kwargs)¶

Overloaded function.

add_coordinate_constraints(pose: pyrosetta.rosetta.core.pose.Pose) -> None
add_coordinate_constraints(pose: pyrosetta.rosetta.core.pose.Pose, coord_sdev: float) -> None
add_coordinate_constraints(pose: pyrosetta.rosetta.core.pose.Pose, coord_sdev: float, include_sc: bool) -> None

handy function for tethering pose to starting coordinates.

C++: core::scoring::constraints::add_coordinate_constraints(class core::pose::Pose &, const double, bool) –> void

add_coordinate_constraints(pose: pyrosetta.rosetta.core.pose.Pose, start_res: int, end_res: int) -> None
add_coordinate_constraints(pose: pyrosetta.rosetta.core.pose.Pose, start_res: int, end_res: int, coord_sdev: float) -> None
add_coordinate_constraints(pose: pyrosetta.rosetta.core.pose.Pose, start_res: int, end_res: int, coord_sdev: float, include_sc: bool) -> None

Add coordinate constraints for starting coordinates, start:end residues, inclusive.

C++: core::scoring::constraints::add_coordinate_constraints(class core::pose::Pose &, const unsigned long, const unsigned long, const double, bool) –> void

pyrosetta.rosetta.core.scoring.constraints.add_fa_constraints_from_cmdline(pose: pyrosetta.rosetta.core.pose.Pose, scorefxn_: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

add constraints if specified by user.

C++: core::scoring::constraints::add_fa_constraints_from_cmdline(class core::pose::Pose &, class core::scoring::ScoreFunction &) –> void

pyrosetta.rosetta.core.scoring.constraints.add_fa_constraints_from_cmdline_to_pose(pose: pyrosetta.rosetta.core.pose.Pose) → None¶

add constraints if specified by user.

C++: core::scoring::constraints::add_fa_constraints_from_cmdline_to_pose(class core::pose::Pose &) –> void

pyrosetta.rosetta.core.scoring.constraints.add_fa_constraints_from_cmdline_to_scorefxn(scorefxn_: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

add constraints if specified by user.

C++: core::scoring::constraints::add_fa_constraints_from_cmdline_to_scorefxn(class core::scoring::ScoreFunction &) –> void

pyrosetta.rosetta.core.scoring.constraints.choose_effective_sequence_separation(sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree, in: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) → None¶

call this on your constraints if you have MultiConstraints before running Abinitio – already done by broker-type application

C++: core::scoring::constraints::choose_effective_sequence_separation(const class core::kinematics::ShortestPathInFoldTree &, 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

pyrosetta.rosetta.core.scoring.constraints.combine_constraints(in: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, combine_ratio: int, exclude_res: pyrosetta.rosetta.utility.vector1_bool, sp: pyrosetta.rosetta.core.kinematics.ShortestPathInFoldTree) → None¶

combine constraints randomly into Ambiguous constraints…

C++: core::scoring::constraints::combine_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> > > &, unsigned long, class utility::vector1<bool, class std::allocator<bool> >, const class core::kinematics::ShortestPathInFoldTree &) –> void

pyrosetta.rosetta.core.scoring.constraints.cull_violators(*args, **kwargs)¶

Overloaded function.

cull_violators(target_list: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, culled_list: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, filter_pose: pyrosetta.rosetta.core.pose.Pose) -> None
cull_violators(target_list: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, culled_list: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, filter_pose: pyrosetta.rosetta.core.pose.Pose, threshold: float) -> None

C++: core::scoring::constraints::cull_violators(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> > > &, 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> > > &, const class core::pose::Pose &, double) –> void

pyrosetta.rosetta.core.scoring.constraints.dexponential(x: float, anchor: float, rate: float, weight: float) → float¶

Returns the weighted value of an Exponential distribution evaluated: with the given anchor, rate, and x values. Returns zero if the weight is less than 1e-10.

C++: core::scoring::constraints::dexponential(double, double, double, double) –> double

pyrosetta.rosetta.core.scoring.constraints.dgaussian(x: float, mean: float, sd: float, weight: float) → float¶: C++: core::scoring::constraints::dgaussian(double, double, double, double) –> double

pyrosetta.rosetta.core.scoring.constraints.drop_constraints(in: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, drop_rate: float) → None¶: C++: core::scoring::constraints::drop_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> > > &, double) –> void

pyrosetta.rosetta.core.scoring.constraints.exponential_deriv(x: float, anchor: float, rate: float, weight: float) → float¶

Returns the weighted derivative of an Exponential distribution: evaluated with the given anchor, rate, and x values. Returns zero if the weight is less than 1e-10.

C++: core::scoring::constraints::exponential_deriv(double, double, double, double) –> double

pyrosetta.rosetta.core.scoring.constraints.gaussian_deriv(x: float, mean: float, sd: float, weight: float) → float¶

Returns the weighted derivative of a Gaussian distribution: evaluated with the given mean, sd, and x values. Returns zero if the weight is less than 1e-10.

C++: core::scoring::constraints::gaussian_deriv(double, double, double, double) –> double

pyrosetta.rosetta.core.scoring.constraints.get_cst_fa_file_option(*args, **kwargs)¶

Overloaded function.

get_cst_fa_file_option() -> str

/////// FA constraints (add and replace)

C++: core::scoring::constraints::get_cst_fa_file_option() –> std::string

get_cst_fa_file_option(options: pyrosetta.rosetta.utility.options.OptionCollection) -> str

C++: core::scoring::constraints::get_cst_fa_file_option(const class utility::options::OptionCollection &) –> std::string

pyrosetta.rosetta.core.scoring.constraints.get_cst_file_option(*args, **kwargs)¶

Overloaded function.

get_cst_file_option() -> str

/////// Centroid constraints (add and replace)

C++: core::scoring::constraints::get_cst_file_option() –> std::string

get_cst_file_option(options: pyrosetta.rosetta.utility.options.OptionCollection) -> str

C++: core::scoring::constraints::get_cst_file_option(const class utility::options::OptionCollection &) –> std::string

pyrosetta.rosetta.core.scoring.constraints.linear_interpolate(x_val: float, x1: float, x2: float, y1: float, y2: float) → float¶

Estimates the y-value of the given x-value by interpolating between: the given points (x1,y1) and (x2,y2) by using linear interpolation between the two points.

C++: core::scoring::constraints::linear_interpolate(const double, const double, const double, const double, const double) –> double

pyrosetta.rosetta.core.scoring.constraints.logdgaussian(x: float, mean: float, sd: float, weight: float) → float¶

Returns the log of the weighted value of a Gaussian distribution: evaluated with the given mean, sd, and x values. Returns zero if the weight is less than 1e-10.

C++: core::scoring::constraints::logdgaussian(double, double, double, double) –> double

pyrosetta.rosetta.core.scoring.constraints.logdgaussian_deriv(x: float, mean: float, sd: float, weight: float) → float¶

Returns the log of the weighted value of a Gaussian distribution: evaluated with the given mean, sd, and x values. Returns zero if the weight is less than 1e-10.

C++: core::scoring::constraints::logdgaussian_deriv(double, double, double, double) –> double

pyrosetta.rosetta.core.scoring.constraints.map_constraints_from_original_pose(original_pose: pyrosetta.rosetta.core.pose.Pose, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

map constraints to new atom numbers after, e.g. variants change. requires pose to have same number of residues.

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

pyrosetta.rosetta.core.scoring.constraints.merge_constraints_from_cmdline(pose: pyrosetta.rosetta.core.pose.Pose, scorefxn_: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

merge cmdline constraints to pre-existing constraints

C++: core::scoring::constraints::merge_constraints_from_cmdline(class core::pose::Pose &, class core::scoring::ScoreFunction &) –> void

pyrosetta.rosetta.core.scoring.constraints.merge_constraints_from_cmdline_to_pose(pose: pyrosetta.rosetta.core.pose.Pose) → None¶

merge cmdline constraints to pre-existing constraints

C++: core::scoring::constraints::merge_constraints_from_cmdline_to_pose(class core::pose::Pose &) –> void

pyrosetta.rosetta.core.scoring.constraints.merge_constraints_from_cmdline_to_scorefxn(scorefxn_: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

merge cmdline constraints to pre-existing constraints - only adds to ZERO weights; previously nonzero constraint weights are unmodified and a warning is issued

C++: core::scoring::constraints::merge_constraints_from_cmdline_to_scorefxn(class core::scoring::ScoreFunction &) –> void

pyrosetta.rosetta.core.scoring.constraints.merge_fa_constraints_from_cmdline(pose: pyrosetta.rosetta.core.pose.Pose, scorefxn_: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

merge cmdline constraints to pre-existing constraints

C++: core::scoring::constraints::merge_fa_constraints_from_cmdline(class core::pose::Pose &, class core::scoring::ScoreFunction &) –> void

pyrosetta.rosetta.core.scoring.constraints.merge_fa_constraints_from_cmdline_to_pose(pose: pyrosetta.rosetta.core.pose.Pose) → None¶

/////// FA constraints (merge mode)

C++: core::scoring::constraints::merge_fa_constraints_from_cmdline_to_pose(class core::pose::Pose &) –> void

pyrosetta.rosetta.core.scoring.constraints.merge_fa_constraints_from_cmdline_to_scorefxn(scorefxn_: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

merge cmdline constraints to pre-existing constraints - only adds to ZERO weights; previously nonzero constraint weights are unmodified and a warning is issued

C++: core::scoring::constraints::merge_fa_constraints_from_cmdline_to_scorefxn(class core::scoring::ScoreFunction &) –> void

pyrosetta.rosetta.core.scoring.constraints.options_for_get_cst_fa_file_option(opts: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None¶

companion function for get_cst_file_option

C++: core::scoring::constraints::options_for_get_cst_fa_file_option(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

pyrosetta.rosetta.core.scoring.constraints.options_for_get_cst_file_option(opts: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None¶

companion function for get_cst_file_option

C++: core::scoring::constraints::options_for_get_cst_file_option(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

pyrosetta.rosetta.core.scoring.constraints.parse_NMR_name(name: str, res: int, aa: pyrosetta.rosetta.core.chemical.AA, : pyrosetta.rosetta.utility.vector1_core_id_NamedAtomID) → None¶: C++: core::scoring::constraints::parse_NMR_name(std::string, unsigned long, enum core::chemical::AA, class utility::vector1<class core::id::NamedAtomID, class std::allocator<class core::id::NamedAtomID> > &) –> void

pyrosetta.rosetta.core.scoring.constraints.print_atom_pair_constraints(*args, **kwargs)¶

Overloaded function.

print_atom_pair_constraints(pose: pyrosetta.rosetta.core.pose.Pose) -> None
print_atom_pair_constraints(pose: pyrosetta.rosetta.core.pose.Pose, out: pyrosetta.rosetta.std.ostream) -> None

example of how to go through a pose constraint set and print out stuff.

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

pyrosetta.rosetta.core.scoring.constraints.remove_constraints_of_type(*args, **kwargs)¶

Overloaded function.

remove_constraints_of_type(pose: pyrosetta.rosetta.core.pose.Pose, type: str) -> None

Remove all constraints of a given type from a pose.

C++: core::scoring::constraints::remove_constraints_of_type(class core::pose::Pose &, const std::string &) –> void

remove_constraints_of_type(pose: pyrosetta.rosetta.core.pose.Pose, type: str, start_res: int, end_res: int) -> None

Remove all constraints of a given type from a pose that involve start_res to end_res. Useful for coordinate/dihedral constraints

C++: core::scoring::constraints::remove_constraints_of_type(class core::pose::Pose &, const std::string &, const unsigned long, const unsigned long) –> void

pyrosetta.rosetta.core.scoring.constraints.remove_nonbb_constraints(pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::constraints::remove_nonbb_constraints(class core::pose::Pose &) –> void

pyrosetta.rosetta.core.scoring.constraints.skip_redundant_constraints(*args, **kwargs)¶

Overloaded function.

skip_redundant_constraints(in: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, total_residue: int) -> None
skip_redundant_constraints(in: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, total_residue: int, influence_width: int) -> None

have at most one constraint per residue pair…

C++: core::scoring::constraints::skip_redundant_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> > > &, unsigned long, unsigned long) –> void