| | |
- builtins.object
-
- Constraint
-
- AmbiguousNMRDistanceConstraint
- AngleConstraint
-
- NamedAngleConstraint
- AtomPairConstraint
-
- NamedAtomPairConstraint
- BackboneStubConstraint
- BackboneStubLinearConstraint
- BigBinConstraint
- ConstantConstraint
- CoordinateConstraint
- DihedralConstraint
-
- NamedDihedralConstraint
- DihedralPairConstraint
- DistancePairConstraint
- LocalCoordinateConstraint
- MultiConstraint
-
- AmbiguousConstraint
-
- SiteConstraint
- SiteConstraintResidues
- AmbiguousNMRConstraint
- FabConstraint
- KofNConstraint
- NonResidueTypeConstraint
- ResidueTypeConstraint
- ResidueTypeLinkingConstraint
- SequenceProfileConstraint
- ConstraintCreator
-
- AmbiguousConstraintCreator
- AmbiguousNMRConstraintCreator
- AmbiguousNMRDistanceConstraintCreator
- AngleConstraintCreator
- AtomPairConstraintCreator
- BigBinConstraintCreator
- CoordinateConstraintCreator
- DihedralConstraintCreator
- DihedralPairConstraintCreator
- FabConstraintCreator
- KofNConstraintCreator
- LocalCoordinateConstraintCreator
- MultiConstraintCreator
- NamedAngleConstraintCreator
- SequenceProfileConstraintCreator
- SiteConstraintCreator
- SiteConstraintResiduesCreator
- ConstraintSet
- Constraints
- DOF_Constraint
- Obsolet_NamedAtomPairConstraint
- ResidueConstraints
- rosetta.basic.datacache.CacheableData(builtins.object)
-
- CstMinimizationData
- rosetta.core.graph.Edge(builtins.object)
-
- ConstraintEdge
- rosetta.core.graph.Graph(builtins.object)
-
- ConstraintGraph
- rosetta.core.graph.Node(builtins.object)
-
- ConstraintNode
- rosetta.core.scoring.LREnergyContainer(builtins.object)
-
- CstEnergyContainer
- rosetta.core.scoring.ResidueNeighborConstIterator(builtins.object)
-
- CstResNeighbConstIterator
- rosetta.core.scoring.ResidueNeighborIterator(builtins.object)
-
- CstResNeighbIterator
- rosetta.core.scoring.func.Func(builtins.object)
-
- BoundFunc
-
- OffsetPeriodicBoundFunc
- PeriodicBoundFunc
- rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy(rosetta.core.scoring.methods.LongRangeTwoBodyEnergy)
-
- ConstraintsEnergy
- rosetta.core.scoring.methods.EnergyMethodCreator(builtins.object)
-
- ConstraintsEnergyCreator
- rosetta.utility.SingletonBase_core_scoring_constraints_ConstraintFactory_t(builtins.object)
-
- ConstraintFactory
- rosetta.utility.SingletonBase_core_scoring_constraints_ConstraintIO_t(builtins.object)
-
- ConstraintIO
class AmbiguousConstraint(MultiConstraint) |
| |
Nested constraint where only the one with lowest energy is considered.
|
| |
- Method resolution order:
- AmbiguousConstraint
- MultiConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.AmbiguousConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(self : handle, cst_in : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- active_constraint(...) from builtins.PyCapsule
- active_constraint(rosetta.core.scoring.constraints.AmbiguousConstraint) -> rosetta.core.scoring.constraints.Constraint
- calculate_total_cst_score(...) from builtins.PyCapsule
- calculate_total_cst_score(self : rosetta.core.scoring.constraints.AmbiguousConstraint, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> float
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.AmbiguousConstraint) -> rosetta.core.scoring.constraints.Constraint
- empty_clone(...) from builtins.PyCapsule
- empty_clone(rosetta.core.scoring.constraints.AmbiguousConstraint) -> rosetta.core.scoring.constraints.MultiConstraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.AmbiguousConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
compute atom deriv
- init_cst_score_types(...) from builtins.PyCapsule
- init_cst_score_types(rosetta.core.scoring.constraints.AmbiguousConstraint) -> NoneType
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.AmbiguousConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.AmbiguousConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.AmbiguousConstraint, xyz_func : core::scoring::func::XYZ_Func, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
compute score
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.AmbiguousConstraint) -> str
Methods inherited from MultiConstraint:
- add_individual_constraint(...) from builtins.PyCapsule
- add_individual_constraint(self : rosetta.core.scoring.constraints.MultiConstraint, cst_in : rosetta.core.scoring.constraints.Constraint) -> NoneType
add individual constraint into MultiConstraint
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.MultiConstraint, n : int) -> rosetta.core.id.AtomID
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- member_constraints(...) from builtins.PyCapsule
- member_constraints(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.MultiConstraint) -> int
number of atoms involved in this MultiConstraint container
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose) -> rosetta.core.scoring.constraints.Constraint
2. remapped_clone(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.utility.vector1_unsigned_long
- set_effective_sequence_separation(...) from builtins.PyCapsule
- set_effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, setting : int) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.MultiConstraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- size(...) from builtins.PyCapsule
- size(rosetta.core.scoring.constraints.MultiConstraint) -> int
number of constraints that are held by this %MultiConstraint
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class AmbiguousNMRConstraint(MultiConstraint) |
| | |
- Method resolution order:
- AmbiguousNMRConstraint
- MultiConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.AmbiguousNMRConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
doc
2. __init__(self : handle, func : core::scoring::func::Func) -> NoneType
3. __init__(self : handle, cst_in : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, func : core::scoring::func::Func) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- add_individual_constraint(...) from builtins.PyCapsule
- add_individual_constraint(self : rosetta.core.scoring.constraints.AmbiguousNMRConstraint, cst_in : rosetta.core.scoring.constraints.Constraint) -> NoneType
add individual constraint into AmbiguousNMRConstraint
- clone(...) from builtins.PyCapsule
- clone(*args, **kwargs)
Overloaded function.
1. clone(rosetta.core.scoring.constraints.AmbiguousNMRConstraint) -> rosetta.core.scoring.constraints.Constraint
2. clone(self : rosetta.core.scoring.constraints.AmbiguousNMRConstraint, func : core::scoring::func::Func) -> rosetta.core.scoring.constraints.Constraint
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.AmbiguousNMRConstraint, pose : rosetta.core.pose.Pose) -> float
2. dist(self : rosetta.core.scoring.constraints.AmbiguousNMRConstraint, xyz : core::scoring::func::XYZ_Func) -> float
- empty_clone(...) from builtins.PyCapsule
- empty_clone(rosetta.core.scoring.constraints.AmbiguousNMRConstraint) -> rosetta.core.scoring.constraints.MultiConstraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.AmbiguousNMRConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
compute atom deriv
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.AmbiguousNMRConstraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.AmbiguousNMRConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.AmbiguousNMRConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(*args, **kwargs)
Overloaded function.
1. score(self : rosetta.core.scoring.constraints.AmbiguousNMRConstraint, xyz_func : core::scoring::func::XYZ_Func, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
compute score
2. score(self : rosetta.core.scoring.constraints.AmbiguousNMRConstraint, pose : rosetta.core.pose.Pose) -> float
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.AmbiguousNMRConstraint) -> str
Methods inherited from MultiConstraint:
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.MultiConstraint, n : int) -> rosetta.core.id.AtomID
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- member_constraints(...) from builtins.PyCapsule
- member_constraints(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.MultiConstraint) -> int
number of atoms involved in this MultiConstraint container
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose) -> rosetta.core.scoring.constraints.Constraint
2. remapped_clone(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.utility.vector1_unsigned_long
- set_effective_sequence_separation(...) from builtins.PyCapsule
- set_effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, setting : int) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.MultiConstraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- size(...) from builtins.PyCapsule
- size(rosetta.core.scoring.constraints.MultiConstraint) -> int
number of constraints that are held by this %MultiConstraint
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class AmbiguousNMRDistanceConstraint(Constraint) |
| | |
- Method resolution order:
- AmbiguousNMRDistanceConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle, rosetta.utility.vector1_core_id_AtomID, rosetta.utility.vector1_core_id_AtomID, rosetta.core.scoring.func.Func) -> NoneType
doc
2. __init__(self : handle, a1 : rosetta.utility.vector1_core_id_AtomID, a2 : rosetta.utility.vector1_core_id_AtomID, func : rosetta.core.scoring.func.Func, scoretype : rosetta.core.scoring.ScoreType) -> NoneType
3. __init__(handle, rosetta.core.id.NamedAtomID, rosetta.core.id.NamedAtomID, rosetta.core.pose.Pose, rosetta.core.scoring.func.Func) -> NoneType
doc
4. __init__(self : handle, a1 : rosetta.core.id.NamedAtomID, a2 : rosetta.core.id.NamedAtomID, : rosetta.core.pose.Pose, func : rosetta.core.scoring.func.Func, scoretype : rosetta.core.scoring.ScoreType) -> NoneType
5. __init__(handle) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, n : int) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(*args, **kwargs)
Overloaded function.
1. clone(rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint) -> rosetta.core.scoring.constraints.Constraint
2. clone(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, func : rosetta.core.scoring.func.Func) -> rosetta.core.scoring.constraints.Constraint
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, pose : rosetta.core.pose.Pose) -> float
2. dist(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, xyz : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint) -> rosetta.core.scoring.func.Func
- inv_dist6(...) from builtins.PyCapsule
- inv_dist6(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, xyz : core::scoring::func::XYZ_Func) -> float
- map_to_CEN(...) from builtins.PyCapsule
- map_to_CEN(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, src : rosetta.core.pose.Pose, centroid : rosetta.core.pose.Pose, nr_mapped : int, map_atom : str) -> rosetta.core.scoring.constraints.Constraint
returns AtomPairConstraint or AmbigousNMRDistanceConstraint (e.g. for GLY HA1-HA2 ... )
- multiplicity(...) from builtins.PyCapsule
- multiplicity(rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint) -> int
- natoms(...) from builtins.PyCapsule
- natoms(*args, **kwargs)
Overloaded function.
1. natoms(rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint) -> int
2. natoms(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, i : int) -> int
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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.
2. remapped_clone(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- resid(...) from builtins.PyCapsule
- resid(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, i : int) -> int
return residue number: i=1,2
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(*args, **kwargs)
Overloaded function.
1. score(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, xyz : core::scoring::func::XYZ_Func, : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
2. score(self : rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint, pose : rosetta.core.pose.Pose) -> float
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.AmbiguousNMRDistanceConstraint) -> str
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class AngleConstraint(Constraint) |
| |
An Angular Constraint.
|
| |
- Method resolution order:
- AngleConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.AngleConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
possibility to compare constraint according to data
and not just pointers
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.scoring.func.Func) -> NoneType
doc
2. __init__(self : handle, a1 : rosetta.core.id.AtomID, a2 : rosetta.core.id.AtomID, a3 : rosetta.core.id.AtomID, func_in : rosetta.core.scoring.func.Func, scotype : rosetta.core.scoring.ScoreType) -> NoneType
3. __init__(handle, rosetta.core.scoring.func.Func) -> NoneType
doc
4. __init__(self : handle, func_in : rosetta.core.scoring.func.Func, scoretype : rosetta.core.scoring.ScoreType) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.AngleConstraint, n : int) -> rosetta.core.id.AtomID
return AtomID for atom 1,2,3
- atom1(...) from builtins.PyCapsule
- atom1(rosetta.core.scoring.constraints.AngleConstraint) -> rosetta.core.id.AtomID
- atom2(...) from builtins.PyCapsule
- atom2(rosetta.core.scoring.constraints.AngleConstraint) -> rosetta.core.id.AtomID
- atom3(...) from builtins.PyCapsule
- atom3(rosetta.core.scoring.constraints.AngleConstraint) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.AngleConstraint) -> rosetta.core.scoring.constraints.Constraint
- dfunc(...) from builtins.PyCapsule
- dfunc(self : rosetta.core.scoring.constraints.AngleConstraint, theta : float) -> float
evaluate dfunc at theta
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.AngleConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
compute atom deriv
- func(...) from builtins.PyCapsule
- func(self : rosetta.core.scoring.constraints.AngleConstraint, theta : float) -> float
evaluate func at theta
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.AngleConstraint) -> rosetta.core.scoring.func.Func
- helper(...) from builtins.PyCapsule
- helper(M : rosetta.numeric.xyzVector_double_t, w : rosetta.numeric.xyzVector_double_t, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.AngleConstraint) -> int
number of atoms --- always 3 for angles
- p1_deriv(...) from builtins.PyCapsule
- p1_deriv(self : rosetta.core.scoring.constraints.AngleConstraint, p1 : rosetta.numeric.xyzVector_double_t, p2 : rosetta.numeric.xyzVector_double_t, p3 : rosetta.numeric.xyzVector_double_t, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType
- p1_theta_deriv(...) from builtins.PyCapsule
- p1_theta_deriv(p1 : rosetta.numeric.xyzVector_double_t, p2 : rosetta.numeric.xyzVector_double_t, p3 : rosetta.numeric.xyzVector_double_t, f1 : rosetta.numeric.xyzVector_double_t, f2 : rosetta.numeric.xyzVector_double_t) -> NoneType
- p2_deriv(...) from builtins.PyCapsule
- p2_deriv(self : rosetta.core.scoring.constraints.AngleConstraint, p1 : rosetta.numeric.xyzVector_double_t, p2 : rosetta.numeric.xyzVector_double_t, p3 : rosetta.numeric.xyzVector_double_t, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.AngleConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.AngleConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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.
2. remapped_clone(self : rosetta.core.scoring.constraints.AngleConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.AngleConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(*args, **kwargs)
Overloaded function.
1. score(self : rosetta.core.scoring.constraints.AngleConstraint, xyz1 : rosetta.numeric.xyzVector_double_t, xyz2 : rosetta.numeric.xyzVector_double_t, xyz3 : rosetta.numeric.xyzVector_double_t) -> float
compute score
2. score(self : rosetta.core.scoring.constraints.AngleConstraint, xyz : core::scoring::func::XYZ_Func, : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
compute score
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.AngleConstraint) -> str
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class AtomPairConstraint(Constraint) |
| | |
- Method resolution order:
- AtomPairConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.AtomPairConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Compare a) the class types (w/ same_type_as_me), b) the atoms being constrained,
c) the score_type being used, and d) the Func objects (the FuncOPs may point at different
objects, but as long as those objects are equal, that counts)
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(handle, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.scoring.func.Func) -> NoneType
doc
3. __init__(self : handle, a1 : rosetta.core.id.AtomID, a2 : rosetta.core.id.AtomID, func : rosetta.core.scoring.func.Func, scoretype : rosetta.core.scoring.ScoreType) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.AtomPairConstraint, n : int) -> rosetta.core.id.AtomID
- atom1(...) from builtins.PyCapsule
- atom1(rosetta.core.scoring.constraints.AtomPairConstraint) -> rosetta.core.id.AtomID
- atom2(...) from builtins.PyCapsule
- atom2(rosetta.core.scoring.constraints.AtomPairConstraint) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(*args, **kwargs)
Overloaded function.
1. clone(rosetta.core.scoring.constraints.AtomPairConstraint) -> rosetta.core.scoring.constraints.Constraint
Create a deep copy of this %AtomPairConstraint, cloning its Func
2. clone(self : rosetta.core.scoring.constraints.AtomPairConstraint, func : rosetta.core.scoring.func.Func) -> 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.
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.AtomPairConstraint, pose : rosetta.core.pose.Pose) -> float
2. dist(self : rosetta.core.scoring.constraints.AtomPairConstraint, conformation : rosetta.core.conformation.Conformation) -> float
3. dist(self : rosetta.core.scoring.constraints.AtomPairConstraint, xyz : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.AtomPairConstraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.AtomPairConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.AtomPairConstraint) -> rosetta.core.scoring.func.Func
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.AtomPairConstraint) -> int
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.AtomPairConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.AtomPairConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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.
2. remapped_clone(self : rosetta.core.scoring.constraints.AtomPairConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.AtomPairConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(*args, **kwargs)
Overloaded function.
1. score(self : rosetta.core.scoring.constraints.AtomPairConstraint, xyz1 : rosetta.numeric.xyzVector_double_t, xyz2 : rosetta.numeric.xyzVector_double_t) -> float
2. score(self : rosetta.core.scoring.constraints.AtomPairConstraint, xyz : core::scoring::func::XYZ_Func, : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
3. score(self : rosetta.core.scoring.constraints.AtomPairConstraint, pose : rosetta.core.pose.Pose) -> float
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.AtomPairConstraint) -> str
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class BackboneStubConstraint(Constraint) |
| |
This constraint favors the backbone landing on a "stub" backbone, which puts the sidechain in a pre-determined desirable location
|
| |
- Method resolution order:
- BackboneStubConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.BackboneStubConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
possibility to compare constraint according to data
and not just pointers
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(self : handle, pose : rosetta.core.pose.Pose, seqpos : int, fixed_atom_id : rosetta.core.id.AtomID, target_pose : rosetta.core.pose.Pose, target_seqpos : int, superposition_bonus : float, force_constant : float) -> NoneType
2. __init__(self : handle, pose : rosetta.core.pose.Pose, seqpos : int, fixed_atom_id : rosetta.core.id.AtomID, target_rsd : rosetta.core.conformation.Residue, superposition_bonus : float, force_constant : float, sidechain_atom_name : str, primary_backbone_atom_name : str, backbone_atom1_name : str, backbone_atom2_name : str) -> NoneType
3. __init__(self : handle, pose : rosetta.core.pose.Pose, seqpos : int, fixed_atom_id : rosetta.core.id.AtomID, target_rsd : rosetta.core.conformation.Residue, superposition_bonus : float, force_constant : float) -> NoneType
4. __init__(handle, rosetta.core.scoring.constraints.BackboneStubConstraint) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.BackboneStubConstraint, index : int) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.BackboneStubConstraint) -> rosetta.core.scoring.constraints.Constraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.BackboneStubConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.BackboneStubConstraint) -> int
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.BackboneStubConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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.
2. remapped_clone(self : rosetta.core.scoring.constraints.BackboneStubConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.BackboneStubConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.BackboneStubConstraint, xyz_func : core::scoring::func::XYZ_Func, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
- seqpos(...) from builtins.PyCapsule
- seqpos(rosetta.core.scoring.constraints.BackboneStubConstraint) -> int
returns the private member seqpos_
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.BackboneStubConstraint) -> str
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.id.SequenceMapping) -> 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.
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class BackboneStubLinearConstraint(Constraint) |
| |
This constraint favors the backbone landing on a "stub" backbone, which puts the sidechain in a pre-determined desirable location
|
| |
- Method resolution order:
- BackboneStubLinearConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.BackboneStubLinearConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
possibility to compare constraint according to data
and not just pointers
- __init__(...) from builtins.PyCapsule
- __init__(self : handle, pose : rosetta.core.pose.Pose, seqpos : int, fixed_atom_id : rosetta.core.id.AtomID, target_rsd : rosetta.core.conformation.Residue, superposition_bonus : float, CB_force_constant : float) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.BackboneStubLinearConstraint, index : int) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.BackboneStubLinearConstraint) -> rosetta.core.scoring.constraints.Constraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.BackboneStubLinearConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.BackboneStubLinearConstraint) -> int
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.BackboneStubLinearConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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.
2. remapped_clone(self : rosetta.core.scoring.constraints.BackboneStubLinearConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.BackboneStubLinearConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.BackboneStubLinearConstraint, xyz_func : core::scoring::func::XYZ_Func, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
- seqpos(...) from builtins.PyCapsule
- seqpos(rosetta.core.scoring.constraints.BackboneStubLinearConstraint) -> int
returns the private member seqpos_
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.BackboneStubLinearConstraint) -> str
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.id.SequenceMapping) -> 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.
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class BigBinConstraint(Constraint) |
| |
constraint on dihedral angle formed by 4 points
|
| |
- Method resolution order:
- BigBinConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.BigBinConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, str) -> NoneType
doc
2. __init__(self : handle, C0 : rosetta.core.id.AtomID, N1 : rosetta.core.id.AtomID, CA1 : rosetta.core.id.AtomID, C1 : rosetta.core.id.AtomID, N2 : rosetta.core.id.AtomID, CA2 : rosetta.core.id.AtomID, bin : str, scotype : rosetta.core.scoring.ScoreType) -> NoneType
3. __init__(handle) -> NoneType
4. __init__(self : handle, res : int, bin : str, sdev : float) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.BigBinConstraint, n : int) -> rosetta.core.id.AtomID
- bin(...) from builtins.PyCapsule
- bin(rosetta.core.scoring.constraints.BigBinConstraint) -> str
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.BigBinConstraint) -> rosetta.core.scoring.constraints.Constraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.BigBinConstraint, : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, : rosetta.numeric.xyzVector_double_t, : rosetta.numeric.xyzVector_double_t, : rosetta.core.scoring.EMapVector) -> NoneType
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.BigBinConstraint) -> int
- res(...) from builtins.PyCapsule
- res(rosetta.core.scoring.constraints.BigBinConstraint) -> int
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.BigBinConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.BigBinConstraint, xyz : core::scoring::func::XYZ_Func, : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
- sdev(...) from builtins.PyCapsule
- sdev(rosetta.core.scoring.constraints.BigBinConstraint) -> float
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.BigBinConstraint) -> str
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.id.SequenceMapping) -> 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.
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class BoundFunc(rosetta.core.scoring.func.Func) |
| | |
- Method resolution order:
- BoundFunc
- rosetta.core.scoring.func.Func
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.BoundFunc, rhs : rosetta.core.scoring.func.Func) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(self : handle, lb : float, ub : float, sd : float, type : str) -> NoneType
2. __init__(self : handle, lb : float, ub : float, sd : float, rswitch : float, type : str) -> NoneType
3. __init__(handle, rosetta.core.scoring.constraints.BoundFunc) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.core.scoring.constraints.BoundFunc, : rosetta.core.scoring.constraints.BoundFunc) -> rosetta.core.scoring.constraints.BoundFunc
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.BoundFunc) -> rosetta.core.scoring.func.Func
- dfunc(...) from builtins.PyCapsule
- dfunc(self : rosetta.core.scoring.constraints.BoundFunc, x : float) -> float
- func(...) from builtins.PyCapsule
- func(self : rosetta.core.scoring.constraints.BoundFunc, x : float) -> float
- lb(...) from builtins.PyCapsule
- lb(rosetta.core.scoring.constraints.BoundFunc) -> float
- rswitch(...) from builtins.PyCapsule
- rswitch(rosetta.core.scoring.constraints.BoundFunc) -> float
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.BoundFunc, other : rosetta.core.scoring.func.Func) -> bool
- sd(...) from builtins.PyCapsule
- sd(rosetta.core.scoring.constraints.BoundFunc) -> float
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.BoundFunc) -> str
- ub(...) from builtins.PyCapsule
- ub(rosetta.core.scoring.constraints.BoundFunc) -> float
Methods inherited from rosetta.core.scoring.func.Func:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.func.Func, other : rosetta.core.scoring.func.Func) -> bool
inequality operator -- simply the negation of the (virtual) equality operator
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.func.Func) -> str
- estimate_dfunc(...) from builtins.PyCapsule
- estimate_dfunc(*args, **kwargs)
Overloaded function.
1. estimate_dfunc(self : 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).
2. estimate_dfunc(self : 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).
|
class ConstantConstraint(Constraint) |
| |
A Constant Constraint.
|
| |
- Method resolution order:
- ConstantConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.ConstantConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle, rosetta.core.scoring.func.Func) -> NoneType
doc
2. __init__(self : handle, func_in : rosetta.core.scoring.func.Func, scotype : rosetta.core.scoring.ScoreType) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.ConstantConstraint, n : int) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.ConstantConstraint) -> rosetta.core.scoring.constraints.Constraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.ConstantConstraint, : rosetta.core.id.AtomID, : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, : rosetta.core.scoring.EMapVector) -> NoneType
compute atom deriv
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.ConstantConstraint) -> int
number of atoms --- zero
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.ConstantConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(*args, **kwargs)
Overloaded function.
1. score(rosetta.core.scoring.constraints.ConstantConstraint) -> float
compute score
2. score(self : rosetta.core.scoring.constraints.ConstantConstraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
compute score
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.ConstantConstraint) -> str
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.id.SequenceMapping) -> 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.
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class Constraint(builtins.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.
|
| |
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.scoring.constraints.Constraint) -> bool
Equality operator to test whether two constraints are functionally
identical.
This operator should use floating point comparison and should not
decide that two floats are identical if they are within some epsilon > 0.
This method allows developes to remove specific constraints from Poses, even
if the constraints have been cloned. Remapped constraints should not be
considered identical -- i.e., if cst1 is between residues i and j and
cst2 is between residues i+1 and j+1. All subclasses of Constraint must
implement this method.
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(self : rosetta.core.scoring.constraints.Constraint, t : rosetta.core.scoring.ScoreType) -> NoneType
2. __init__(rosetta.core.scoring.constraints.Constraint, rosetta.core.scoring.constraints.Constraint) -> NoneType
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.Constraint, index : int) -> rosetta.core.id.AtomID
Returns the AtomID referred to by index.
Note that this function isn't actually used by the constraint scoring machenery.
If you're calling it on a generic Constraint (as opposed to specifically on a derived class)
you're probably doing something wrong.
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- clone(...) from builtins.PyCapsule
- clone(*args, **kwargs)
Overloaded function.
1. clone(rosetta.core.scoring.constraints.Constraint) -> 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.
2. clone(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::Func) -> rosetta.core.scoring.constraints.Constraint
Clone the constraint, but where a new Func object is to be used instead.
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.Constraint, atom : rosetta.core.id.AtomID, xyz_func : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
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!)
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- natoms(...) from builtins.PyCapsule
- natoms(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.
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.id.SequenceMapping) -> 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.
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.Constraint, other : 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.
- score(...) from builtins.PyCapsule
- score(*args, **kwargs)
Overloaded function.
1. score(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
2. score(self : rosetta.core.scoring.constraints.Constraint, xyz_func : core::scoring::func::XYZ_Func, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
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.
3. score(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.conformation.Conformation) -> float
Returns the score of this constraint computed over the given conformation.
Not necessarily implemented in all derived classes, as it's redundant with
the score( XYZ_Func, EnergyMap, EnergyMap ) method defined above. Returns
0.0 if not implemented.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.Constraint) -> str
Returns a unique string identified for this constraint. Used in several
places, including the ConstraintIO class.
|
class ConstraintEdge(rosetta.core.graph.Edge) |
| | |
- Method resolution order:
- ConstraintEdge
- rosetta.core.graph.Edge
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(self : handle, owner : rosetta.core.graph.Graph, first_node_ind : int, second_node_ind : int) -> NoneType
2. __init__(self : handle, owner : rosetta.core.graph.Graph, example_edge : rosetta.core.scoring.constraints.ConstraintEdge) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- angle_constraint_energy(...) from builtins.PyCapsule
- angle_constraint_energy(*args, **kwargs)
Overloaded function.
1. angle_constraint_energy(self : rosetta.core.scoring.constraints.ConstraintEdge, : float) -> NoneType
2. angle_constraint_energy(rosetta.core.scoring.constraints.ConstraintEdge) -> float
- atom_pair_constraint_energy(...) from builtins.PyCapsule
- atom_pair_constraint_energy(*args, **kwargs)
Overloaded function.
1. atom_pair_constraint_energy(self : rosetta.core.scoring.constraints.ConstraintEdge, : float) -> NoneType
2. atom_pair_constraint_energy(rosetta.core.scoring.constraints.ConstraintEdge) -> float
- backbone_stub_constraint_energy(...) from builtins.PyCapsule
- backbone_stub_constraint_energy(*args, **kwargs)
Overloaded function.
1. backbone_stub_constraint_energy(self : rosetta.core.scoring.constraints.ConstraintEdge, : float) -> NoneType
2. backbone_stub_constraint_energy(rosetta.core.scoring.constraints.ConstraintEdge) -> float
- backbone_stub_linear_constraint_energy(...) from builtins.PyCapsule
- backbone_stub_linear_constraint_energy(*args, **kwargs)
Overloaded function.
1. backbone_stub_linear_constraint_energy(self : rosetta.core.scoring.constraints.ConstraintEdge, : float) -> NoneType
2. backbone_stub_linear_constraint_energy(rosetta.core.scoring.constraints.ConstraintEdge) -> float
- base_pair_constraint_energy(...) from builtins.PyCapsule
- base_pair_constraint_energy(*args, **kwargs)
Overloaded function.
1. base_pair_constraint_energy(self : rosetta.core.scoring.constraints.ConstraintEdge, : float) -> NoneType
2. base_pair_constraint_energy(rosetta.core.scoring.constraints.ConstraintEdge) -> float
- bond_geometry_energy(...) from builtins.PyCapsule
- bond_geometry_energy(*args, **kwargs)
Overloaded function.
1. bond_geometry_energy(self : rosetta.core.scoring.constraints.ConstraintEdge, : float) -> NoneType
2. bond_geometry_energy(rosetta.core.scoring.constraints.ConstraintEdge) -> float
- coordinate_constraint_energy(...) from builtins.PyCapsule
- coordinate_constraint_energy(*args, **kwargs)
Overloaded function.
1. coordinate_constraint_energy(self : rosetta.core.scoring.constraints.ConstraintEdge, : float) -> NoneType
2. coordinate_constraint_energy(rosetta.core.scoring.constraints.ConstraintEdge) -> float
- copy_from(...) from builtins.PyCapsule
- copy_from(self : rosetta.core.scoring.constraints.ConstraintEdge, source : rosetta.core.graph.Edge) -> NoneType
- count_dynamic_memory(...) from builtins.PyCapsule
- count_dynamic_memory(rosetta.core.scoring.constraints.ConstraintEdge) -> int
- count_static_memory(...) from builtins.PyCapsule
- count_static_memory(rosetta.core.scoring.constraints.ConstraintEdge) -> int
- dihedral_constraint_energy(...) from builtins.PyCapsule
- dihedral_constraint_energy(*args, **kwargs)
Overloaded function.
1. dihedral_constraint_energy(self : rosetta.core.scoring.constraints.ConstraintEdge, : float) -> NoneType
2. dihedral_constraint_energy(rosetta.core.scoring.constraints.ConstraintEdge) -> float
- energy_computed(...) from builtins.PyCapsule
- energy_computed(*args, **kwargs)
Overloaded function.
1. energy_computed(self : rosetta.core.scoring.constraints.ConstraintEdge, setting : bool) -> NoneType
2. energy_computed(rosetta.core.scoring.constraints.ConstraintEdge) -> bool
- metalbinding_constraint_energy(...) from builtins.PyCapsule
- metalbinding_constraint_energy(*args, **kwargs)
Overloaded function.
1. metalbinding_constraint_energy(self : rosetta.core.scoring.constraints.ConstraintEdge, : float) -> NoneType
2. metalbinding_constraint_energy(rosetta.core.scoring.constraints.ConstraintEdge) -> float
- res_type_linking_constraint_energy(...) from builtins.PyCapsule
- res_type_linking_constraint_energy(*args, **kwargs)
Overloaded function.
1. res_type_linking_constraint_energy(self : rosetta.core.scoring.constraints.ConstraintEdge, : float) -> NoneType
2. res_type_linking_constraint_energy(rosetta.core.scoring.constraints.ConstraintEdge) -> float
- rna_bond_geometry_energy(...) from builtins.PyCapsule
- rna_bond_geometry_energy(*args, **kwargs)
Overloaded function.
1. rna_bond_geometry_energy(self : rosetta.core.scoring.constraints.ConstraintEdge, : float) -> NoneType
2. rna_bond_geometry_energy(rosetta.core.scoring.constraints.ConstraintEdge) -> float
Methods inherited from rosetta.core.graph.Edge:
- get_first_node_ind(...) from builtins.PyCapsule
- get_first_node_ind(rosetta.core.graph.Edge) -> int
returns the index of the lower node
- get_other_ind(...) from builtins.PyCapsule
- get_other_ind(self : rosetta.core.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.
- get_other_node(...) from builtins.PyCapsule
- get_other_node(*args, **kwargs)
Overloaded function.
1. get_other_node(self : rosetta.core.graph.Edge, node_index : int) -> rosetta.core.graph.Node
returns a 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.
2. get_other_node(self : rosetta.core.graph.Edge, node_index : int) -> rosetta.core.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.
- get_second_node_ind(...) from builtins.PyCapsule
- get_second_node_ind(rosetta.core.graph.Edge) -> int
returns the index of the upper node
- is_loop(...) from builtins.PyCapsule
- is_loop(rosetta.core.graph.Edge) -> bool
Is this edge a loop? In Pseudographs, loop edges are incident twice on a single vertex.
- same_edge(...) from builtins.PyCapsule
- same_edge(self : rosetta.core.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.
- set_pos_in_owners_list(...) from builtins.PyCapsule
- set_pos_in_owners_list(self : rosetta.core.graph.Edge, edge_iterator : rosetta.core.graph.EdgeListIterator) -> NoneType
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.
|
class ConstraintGraph(rosetta.core.graph.Graph) |
| | |
- Method resolution order:
- ConstraintGraph
- rosetta.core.graph.Graph
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(self : handle, num_nodes : int) -> NoneType
3. __init__(handle, rosetta.core.scoring.constraints.ConstraintGraph) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.core.scoring.constraints.ConstraintGraph, source : rosetta.core.scoring.constraints.ConstraintGraph) -> rosetta.core.scoring.constraints.ConstraintGraph
- delete_edge(...) from builtins.PyCapsule
- delete_edge(self : rosetta.core.scoring.constraints.ConstraintGraph, edge : rosetta.core.graph.Edge) -> NoneType
Methods inherited from rosetta.core.graph.Graph:
- add_edge(...) from builtins.PyCapsule
- add_edge(*args, **kwargs)
Overloaded function.
1. add_edge(self : rosetta.core.graph.Graph, node1 : int, node2 : int) -> rosetta.core.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.
2. add_edge(self : rosetta.core.graph.Graph, example_edge : rosetta.core.graph.Edge) -> rosetta.core.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.
- all_pairs_shortest_paths(...) from builtins.PyCapsule
- all_pairs_shortest_paths(rosetta.core.graph.Graph) -> ObjexxFCL::FArray2D<int>
O(V^3). Computes all pairs shortest paths using Warshall's algorithm
and writes all the path distances to the two-dimensional table.
- const_edge_list_begin(...) from builtins.PyCapsule
- const_edge_list_begin(rosetta.core.graph.Graph) -> rosetta.core.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
- const_edge_list_end(...) from builtins.PyCapsule
- const_edge_list_end(rosetta.core.graph.Graph) -> rosetta.core.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
- copy_connectivity(...) from builtins.PyCapsule
- copy_connectivity(self : rosetta.core.graph.Graph, source : rosetta.core.graph.Graph) -> NoneType
copy the edge connectivity from a source graph with a potentially
unknown type.
- drop_all_edges(...) from builtins.PyCapsule
- drop_all_edges(rosetta.core.graph.Graph) -> NoneType
delete all the edges present in the graph
- drop_all_edges_for_node(...) from builtins.PyCapsule
- drop_all_edges_for_node(self : rosetta.core.graph.Graph, node : int) -> NoneType
delete all the edges for a single vertex in the graph
- edge_list_begin(...) from builtins.PyCapsule
- edge_list_begin(rosetta.core.graph.Graph) -> rosetta.core.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
- edge_list_end(...) from builtins.PyCapsule
- edge_list_end(rosetta.core.graph.Graph) -> rosetta.core.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
- find_edge(...) from builtins.PyCapsule
- find_edge(*args, **kwargs)
Overloaded function.
1. find_edge(self : rosetta.core.graph.Graph, node1 : int, node2 : int) -> rosetta.core.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.
2. find_edge(self : rosetta.core.graph.Graph, node1 : int, node2 : int) -> rosetta.core.graph.Edge
returns a const 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.
- focused_edge(...) from builtins.PyCapsule
- focused_edge(*args, **kwargs)
Overloaded function.
1. focused_edge(rosetta.core.graph.Graph) -> rosetta.core.graph.Edge
returns a pointer to the focused edge
2. focused_edge(rosetta.core.graph.Graph) -> rosetta.core.graph.Edge
returns a const-pointer to the focused edge
- getTotalMemoryUsage(...) from builtins.PyCapsule
- getTotalMemoryUsage(rosetta.core.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.
- get_edge_exists(...) from builtins.PyCapsule
- get_edge_exists(self : rosetta.core.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
- get_node(...) from builtins.PyCapsule
- get_node(*args, **kwargs)
Overloaded function.
1. get_node(self : rosetta.core.graph.Graph, index : int) -> rosetta.core.graph.Node
2. get_node(self : rosetta.core.graph.Graph, index : int) -> rosetta.core.graph.Node
- get_self_ptr(...) from builtins.PyCapsule
- get_self_ptr(*args, **kwargs)
Overloaded function.
1. get_self_ptr(rosetta.core.graph.Graph) -> rosetta.core.graph.Graph
self pointers
2. get_self_ptr(rosetta.core.graph.Graph) -> rosetta.core.graph.Graph
- num_edges(...) from builtins.PyCapsule
- num_edges(rosetta.core.graph.Graph) -> int
- num_nodes(...) from builtins.PyCapsule
- num_nodes(rosetta.core.graph.Graph) -> int
the number of nodes in the graph
- print_vertices(...) from builtins.PyCapsule
- print_vertices(rosetta.core.graph.Graph) -> NoneType
send summary information to the screen for all vertices in the graph
- set_num_nodes(...) from builtins.PyCapsule
- set_num_nodes(self : rosetta.core.graph.Graph, num_nodes : int) -> NoneType
set the number of nodes in the graph -- deletes any existing edges in the graph
|
class ConstraintIO(rosetta.utility.SingletonBase_core_scoring_constraints_ConstraintIO_t) |
| |
/////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
|
| |
- Method resolution order:
- ConstraintIO
- rosetta.utility.SingletonBase_core_scoring_constraints_ConstraintIO_t
- builtins.object
Methods defined here:
- __init__(self, /, *args, **kwargs)
- Initialize self. See help(type(self)) for accurate signature.
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- get_cst_factory(...) from builtins.PyCapsule
- get_cst_factory() -> rosetta.core.scoring.constraints.ConstraintFactory
- get_func_factory(...) from builtins.PyCapsule
- get_func_factory() -> rosetta.core.scoring.func.FuncFactory
- parse_residue(...) from builtins.PyCapsule
- parse_residue(*args, **kwargs)
Overloaded function.
1. parse_residue(pose : rosetta.core.pose.Pose, residue_string : str, residue_num : int) -> NoneType
2. parse_residue(pose : rosetta.core.pose.Pose, resnum : int) -> int
3. parse_residue(pose : rosetta.core.pose.Pose, resnum : int, chain : str) -> int
- read_constraints(...) from builtins.PyCapsule
- read_constraints(filename : str, cst_set : core::scoring::constraints::ConstraintSet, pose : rosetta.core.pose.Pose) -> core::scoring::constraints::ConstraintSet
- read_constraints_new(...) from builtins.PyCapsule
- read_constraints_new(fname : str, cset : core::scoring::constraints::ConstraintSet, pose : rosetta.core.pose.Pose) -> core::scoring::constraints::ConstraintSet
- write_constraints(...) from builtins.PyCapsule
- write_constraints(filename : str, cst_set : core::scoring::constraints::ConstraintSet, : rosetta.core.pose.Pose) -> NoneType
Methods inherited from rosetta.utility.SingletonBase_core_scoring_constraints_ConstraintIO_t:
- get_instance(...) from builtins.PyCapsule
- get_instance() -> core::scoring::constraints::ConstraintIO
|
class ConstraintNode(rosetta.core.graph.Node) |
| | |
- Method resolution order:
- ConstraintNode
- rosetta.core.graph.Node
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(self : handle, : rosetta.core.graph.Graph, node_id : int) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- copy_from(...) from builtins.PyCapsule
- copy_from(self : rosetta.core.scoring.constraints.ConstraintNode, source : rosetta.core.graph.Node) -> NoneType
- count_dynamic_memory(...) from builtins.PyCapsule
- count_dynamic_memory(rosetta.core.scoring.constraints.ConstraintNode) -> int
- count_static_memory(...) from builtins.PyCapsule
- count_static_memory(rosetta.core.scoring.constraints.ConstraintNode) -> int
Methods inherited from rosetta.core.graph.Node:
- add_edge(...) from builtins.PyCapsule
- add_edge(self : rosetta.core.graph.Node, edge_ptr : core::graph::Edge, : rosetta.core.graph.EdgeListIterator) -> NoneType
adds edge pointer to edge list; returns an iterator to the new
list element
- const_edge_list_begin(...) from builtins.PyCapsule
- const_edge_list_begin(rosetta.core.graph.Node) -> rosetta.core.graph.EdgeListConstIterator
returns a const iterator to the beginning of its edge list
- const_edge_list_end(...) from builtins.PyCapsule
- const_edge_list_end(rosetta.core.graph.Node) -> rosetta.core.graph.EdgeListConstIterator
returns a const iterator to the end of its edge list
- const_lower_edge_list_begin(...) from builtins.PyCapsule
- const_lower_edge_list_begin(rosetta.core.graph.Node) -> rosetta.core.graph.EdgeListConstIterator
returns a const iterator to the beginning of its lower-edge list
- const_lower_edge_list_end(...) from builtins.PyCapsule
- const_lower_edge_list_end(rosetta.core.graph.Node) -> rosetta.core.graph.EdgeListConstIterator
returns a const iterator to the end of its lower-edge list
- const_upper_edge_list_begin(...) from builtins.PyCapsule
- const_upper_edge_list_begin(rosetta.core.graph.Node) -> rosetta.core.graph.EdgeListConstIterator
returns a const iterator to the beginning of its upper-edge list
- const_upper_edge_list_end(...) from builtins.PyCapsule
- const_upper_edge_list_end(rosetta.core.graph.Node) -> rosetta.core.graph.EdgeListConstIterator
returns a const iterator to the end of its upper-edge list
- drop_all_edges(...) from builtins.PyCapsule
- drop_all_edges(rosetta.core.graph.Node) -> NoneType
deletes all edges incident upon this node
- drop_edge(...) from builtins.PyCapsule
- drop_edge(self : rosetta.core.graph.Node, edge_iterator : rosetta.core.graph.EdgeListIterator) -> NoneType
removes an edge iterator from the node's edge list. Only called by Edge class.
- edge_list_begin(...) from builtins.PyCapsule
- edge_list_begin(rosetta.core.graph.Node) -> rosetta.core.graph.EdgeListIterator
returns a non-const iterator to the beginning of its edge list
- edge_list_end(...) from builtins.PyCapsule
- edge_list_end(rosetta.core.graph.Node) -> rosetta.core.graph.EdgeListIterator
returns a non-const iterator to the end of its edge list
- find_edge(...) from builtins.PyCapsule
- find_edge(*args, **kwargs)
Overloaded function.
1. find_edge(self : rosetta.core.graph.Node, other_node_index : int) -> core::graph::Edge
a "slow" (linear) search for an edge.
2. find_edge(self : rosetta.core.graph.Node, other_node_index : int) -> core::graph::Edge
- get_node_index(...) from builtins.PyCapsule
- get_node_index(rosetta.core.graph.Node) -> int
the index for this node
- get_num_edges_to_larger_indexed_nodes(...) from builtins.PyCapsule
- get_num_edges_to_larger_indexed_nodes(rosetta.core.graph.Node) -> int
the number of upper neighbors -- which "self" neighborness is counted if a loop edge
is present
- get_num_edges_to_smaller_indexed_nodes(...) from builtins.PyCapsule
- get_num_edges_to_smaller_indexed_nodes(rosetta.core.graph.Node) -> int
the number of lower neighbors
- loop_incident(...) from builtins.PyCapsule
- loop_incident(rosetta.core.graph.Node) -> bool
NOTE TO SELF: remove loop support
- lower_edge_list_begin(...) from builtins.PyCapsule
- lower_edge_list_begin(rosetta.core.graph.Node) -> rosetta.core.graph.EdgeListIterator
returns a non-const iterator to the beginning of its lower-edge list
- lower_edge_list_end(...) from builtins.PyCapsule
- lower_edge_list_end(rosetta.core.graph.Node) -> rosetta.core.graph.EdgeListIterator
returns a non-const iterator to the end of its lower-edge list
- num_edges(...) from builtins.PyCapsule
- num_edges(rosetta.core.graph.Node) -> int
the number of edges incident on this node, which may include a loop edge
- num_neighbors_counting_self(...) from builtins.PyCapsule
- num_neighbors_counting_self(rosetta.core.graph.Node) -> int
the number of neighbors counting "self" as a neighbor.
- num_neighbors_counting_self_static(...) from builtins.PyCapsule
- num_neighbors_counting_self_static(rosetta.core.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.
- print(...) from builtins.PyCapsule
- print(rosetta.core.graph.Node) -> NoneType
send summaray data about this node to the screen
- set_num_neighbors_counting_self_static(...) from builtins.PyCapsule
- set_num_neighbors_counting_self_static(self : rosetta.core.graph.Node, neighbor : int) -> NoneType
manually change the number of neighbors for a Node. Used
for symmetry scoring
- upper_edge_list_begin(...) from builtins.PyCapsule
- upper_edge_list_begin(rosetta.core.graph.Node) -> rosetta.core.graph.EdgeListIterator
returns a non-const iterator to the beginning of its upper-edge list
- upper_edge_list_end(...) from builtins.PyCapsule
- upper_edge_list_end(rosetta.core.graph.Node) -> rosetta.core.graph.EdgeListIterator
returns a non-const iterator to the end of its upper-edge list
|
class ConstraintSet(builtins.object) |
| |
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
|
| |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(handle, rosetta.core.scoring.constraints.ConstraintSet) -> NoneType
3. __init__(self : handle, other : rosetta.core.scoring.constraints.ConstraintSet, start_residue : int, end_residue : int) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.ConstraintSet) -> str
- add_constraint(...) from builtins.PyCapsule
- add_constraint(self : rosetta.core.scoring.constraints.ConstraintSet, cst : rosetta.core.scoring.constraints.Constraint) -> NoneType
- add_constraints(...) from builtins.PyCapsule
- add_constraints(*args, **kwargs)
Overloaded function.
1. add_constraints(self : rosetta.core.scoring.constraints.ConstraintSet, cst_list : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) -> NoneType
2. add_constraints(self : rosetta.core.scoring.constraints.ConstraintSet, cst_set : rosetta.core.scoring.constraints.ConstraintSet) -> NoneType
add another constraint set to this constraint set
- add_dof_constraint(...) from builtins.PyCapsule
- add_dof_constraint(*args, **kwargs)
Overloaded function.
1. add_dof_constraint(self : rosetta.core.scoring.constraints.ConstraintSet, id : rosetta.core.id.DOF_ID, func : rosetta.core.scoring.func.Func) -> NoneType
Note -- still hacky. Will not be included in packing, just scoring
and minimization
2. add_dof_constraint(self : rosetta.core.scoring.constraints.ConstraintSet, id : rosetta.core.id.DOF_ID, func : rosetta.core.scoring.func.Func, t : rosetta.core.scoring.ScoreType) -> NoneType
Note -- still hacky. Will not be included in packing, just scoring
and minimization
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.core.scoring.constraints.ConstraintSet, rhs : rosetta.core.scoring.constraints.ConstraintSet) -> 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.
- attach_to_conformation(...) from builtins.PyCapsule
- attach_to_conformation(self : rosetta.core.scoring.constraints.ConstraintSet, conformation : rosetta.std.weak_ptr_const_core_conformation_Conformation_t) -> NoneType
- clear(...) from builtins.PyCapsule
- clear(rosetta.core.scoring.constraints.ConstraintSet) -> NoneType
- clear_sequence_constraints(...) from builtins.PyCapsule
- clear_sequence_constraints(rosetta.core.scoring.constraints.ConstraintSet) -> NoneType
Discard any and all sequence constraints in the sequence_constraints_ list.
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.ConstraintSet) -> rosetta.core.scoring.constraints.ConstraintSet
Clone operator -- performs a shallow copy of the contained
constraints.
- deprecated_eval_atom_derivative(...) from builtins.PyCapsule
- deprecated_eval_atom_derivative(self : rosetta.core.scoring.constraints.ConstraintSet, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType
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
- detach_from_conformation(...) from builtins.PyCapsule
- detach_from_conformation(rosetta.core.scoring.constraints.ConstraintSet) -> NoneType
- detached_clone(...) from builtins.PyCapsule
- detached_clone(rosetta.core.scoring.constraints.ConstraintSet) -> rosetta.core.scoring.constraints.ConstraintSet
Clone operator -- performs a shallow copy of the contained
constraints.
- detached_copy(...) from builtins.PyCapsule
- detached_copy(self : rosetta.core.scoring.constraints.ConstraintSet, src : rosetta.core.scoring.constraints.ConstraintSet) -> NoneType
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.
- eval_intrares_energy(...) from builtins.PyCapsule
- eval_intrares_energy(*args, **kwargs)
Overloaded function.
1. eval_intrares_energy(self : rosetta.core.scoring.constraints.ConstraintSet, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType
2. eval_intrares_energy(self : rosetta.core.scoring.constraints.ConstraintSet, rsd : rosetta.core.conformation.Residue, emap : rosetta.core.scoring.EMapVector) -> NoneType
- eval_multibody_atom_derivative(...) from builtins.PyCapsule
- eval_multibody_atom_derivative(self : rosetta.core.scoring.constraints.ConstraintSet, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType
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).
- eval_non_residue_pair_energy(...) from builtins.PyCapsule
- eval_non_residue_pair_energy(self : rosetta.core.scoring.constraints.ConstraintSet, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType
Does *NOT* zero the emap values, just adds the additional contribution to the
existing emap energies (so can be called inside finalize_total_energies)
- get_all_constraints(...) from builtins.PyCapsule
- get_all_constraints(rosetta.core.scoring.constraints.ConstraintSet) -> 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.
- has_constraints(...) from builtins.PyCapsule
- has_constraints(rosetta.core.scoring.constraints.ConstraintSet) -> bool
- has_dof_constraints(...) from builtins.PyCapsule
- has_dof_constraints(rosetta.core.scoring.constraints.ConstraintSet) -> bool
- has_intra_residue_constraints(...) from builtins.PyCapsule
- has_intra_residue_constraints(rosetta.core.scoring.constraints.ConstraintSet) -> bool
- has_non_residue_pair_constraints(...) from builtins.PyCapsule
- has_non_residue_pair_constraints(rosetta.core.scoring.constraints.ConstraintSet) -> bool
- has_residue_pair_constraints(...) from builtins.PyCapsule
- has_residue_pair_constraints(rosetta.core.scoring.constraints.ConstraintSet) -> bool
- is_empty(...) from builtins.PyCapsule
- is_empty(rosetta.core.scoring.constraints.ConstraintSet) -> bool
- n_sequence_constraints(...) from builtins.PyCapsule
- n_sequence_constraints(rosetta.core.scoring.constraints.ConstraintSet) -> int
Get the number of sequence constraints.
- on_connection_change(...) from builtins.PyCapsule
- on_connection_change(self : rosetta.core.scoring.constraints.ConstraintSet, event : rosetta.core.conformation.signals.ConnectionEvent) -> NoneType
- on_length_change(...) from builtins.PyCapsule
- on_length_change(self : rosetta.core.scoring.constraints.ConstraintSet, event : rosetta.core.conformation.signals.LengthEvent) -> NoneType
- remap_residue_positions(...) from builtins.PyCapsule
- remap_residue_positions(self : rosetta.core.scoring.constraints.ConstraintSet, smap : rosetta.core.id.SequenceMapping) -> NoneType
remaps the constraints in this particular constraint set according
to brief the passed in sequence mapping --- redundant with
remapped_clone!!!
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.ConstraintSet, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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 .. NULL = identity mapping to
the new object. This will really clone all constraints since they have to
change their atom-numbers and residue-numbers
2. remapped_clone(self : rosetta.core.scoring.constraints.ConstraintSet, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, smap : rosetta.core.id.SequenceMapping) -> 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 .. NULL = identity mapping to
the new object. This will really clone all constraints since they have to
change their atom-numbers and residue-numbers
- remove_constraint(...) from builtins.PyCapsule
- remove_constraint(self : rosetta.core.scoring.constraints.ConstraintSet, cst : 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
- remove_constraints(...) from builtins.PyCapsule
- remove_constraints(self : rosetta.core.scoring.constraints.ConstraintSet, cst_list : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, object_comparison : bool) -> bool
- residue_pair_constraint_exists(...) from builtins.PyCapsule
- residue_pair_constraint_exists(self : rosetta.core.scoring.constraints.ConstraintSet, pos1 : int, pos2 : int) -> bool
- residue_pair_constraints_begin(...) from builtins.PyCapsule
- residue_pair_constraints_begin(self : rosetta.core.scoring.constraints.ConstraintSet, resid : int) -> std::_Rb_tree_const_iterator<std::pair<unsigned long const, std::shared_ptr<core::scoring::constraints::Constraints> > >
- residue_pair_constraints_end(...) from builtins.PyCapsule
- residue_pair_constraints_end(self : rosetta.core.scoring.constraints.ConstraintSet, resid : int) -> std::_Rb_tree_const_iterator<std::pair<unsigned long const, std::shared_ptr<core::scoring::constraints::Constraints> > >
- residue_pair_constraints_exists(...) from builtins.PyCapsule
- residue_pair_constraints_exists(self : rosetta.core.scoring.constraints.ConstraintSet, pos : int) -> bool
- residue_pair_energy(...) from builtins.PyCapsule
- residue_pair_energy(self : rosetta.core.scoring.constraints.ConstraintSet, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType
- revision_id(...) from builtins.PyCapsule
- revision_id(rosetta.core.scoring.constraints.ConstraintSet) -> int
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(*args, **kwargs)
Overloaded function.
1. same_type_as_me(self : rosetta.core.scoring.constraints.ConstraintSet, other : rosetta.core.scoring.constraints.ConstraintSet) -> 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.
2. same_type_as_me(self : rosetta.core.scoring.constraints.ConstraintSet, other : 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.
- sequence_constraint(...) from builtins.PyCapsule
- sequence_constraint(self : rosetta.core.scoring.constraints.ConstraintSet, index : int) -> rosetta.core.scoring.aa_composition_energy.SequenceConstraint
Get the owning pointer to the Nth sequence constraint.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.ConstraintSet, pose : rosetta.core.pose.Pose, scfxn : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_minimizing_for_residue(...) from builtins.PyCapsule
- setup_for_minimizing_for_residue(self : rosetta.core.scoring.constraints.ConstraintSet, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType
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.
- setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule
- setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.constraints.ConstraintSet, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, respair_data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType
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.
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.ConstraintSet, pose : rosetta.core.pose.Pose, scfxn : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def_clone(...) from builtins.PyCapsule
- steal_def_clone(*args, **kwargs)
Overloaded function.
1. steal_def_clone(self : rosetta.core.scoring.constraints.ConstraintSet, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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
2. steal_def_clone(self : rosetta.core.scoring.constraints.ConstraintSet, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, smap : rosetta.core.id.SequenceMapping) -> 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
|
class Constraints(builtins.object) |
| | |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(handle, rosetta.core.scoring.constraints.Constraints) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- add_constraint(...) from builtins.PyCapsule
- add_constraint(self : rosetta.core.scoring.constraints.Constraints, cst : rosetta.core.scoring.constraints.Constraint) -> NoneType
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.core.scoring.constraints.Constraints, rhs : rosetta.core.scoring.constraints.Constraints) -> rosetta.core.scoring.constraints.Constraints
Copy the contents of the rhs %Constraints object into this %Constraints object
- begin(...) from builtins.PyCapsule
- begin(rosetta.core.scoring.constraints.Constraints) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::constraints::Constraint const> const*, std::vector<std::shared_ptr<core::scoring::constraints::Constraint const>, std::allocator<std::shared_ptr<core::scoring::constraints::Constraint const> > > >
- clear(...) from builtins.PyCapsule
- clear(rosetta.core.scoring.constraints.Constraints) -> NoneType
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.Constraints) -> rosetta.core.scoring.constraints.Constraints
Create a copy of this %Constraints object using the shallow-copy-constructor.
- conformation_energy(...) from builtins.PyCapsule
- conformation_energy(self : rosetta.core.scoring.constraints.Constraints, conformation : rosetta.core.conformation.Conformation, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
- constraints(...) from builtins.PyCapsule
- constraints(rosetta.core.scoring.constraints.Constraints) -> rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t
- deep_clone(...) from builtins.PyCapsule
- deep_clone(rosetta.core.scoring.constraints.Constraints) -> rosetta.core.scoring.constraints.Constraints
Create a deep copy of this %Constraints object, cloning all of the individual constraints
- end(...) from builtins.PyCapsule
- end(rosetta.core.scoring.constraints.Constraints) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::constraints::Constraint const> const*, std::vector<std::shared_ptr<core::scoring::constraints::Constraint const>, std::allocator<std::shared_ptr<core::scoring::constraints::Constraint const> > > >
- eval_intrares_atom_derivative(...) from builtins.PyCapsule
- eval_intrares_atom_derivative(self : rosetta.core.scoring.constraints.Constraints, atom_id : rosetta.core.id.AtomID, residue : rosetta.core.conformation.Residue, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType
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.
- eval_respair_atom_derivative(...) from builtins.PyCapsule
- eval_respair_atom_derivative(self : rosetta.core.scoring.constraints.Constraints, atom_id : rosetta.core.id.AtomID, residue1 : rosetta.core.conformation.Residue, residue2 : rosetta.core.conformation.Residue, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType
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.
- eval_ws_atom_derivative(...) from builtins.PyCapsule
- eval_ws_atom_derivative(self : rosetta.core.scoring.constraints.Constraints, atom_id : rosetta.core.id.AtomID, conformation : rosetta.core.conformation.Conformation, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType
Evaluate derivatives giving the Constraint objects held within this object
the entire Conformation (a whole structure, ws) with which to work.
- intra_residue_energy(...) from builtins.PyCapsule
- intra_residue_energy(self : rosetta.core.scoring.constraints.Constraints, rsd : rosetta.core.conformation.Residue, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
will fail if Residue doesnt contain all the necessary atoms
- remove_constraint(...) from builtins.PyCapsule
- remove_constraint(self : rosetta.core.scoring.constraints.Constraints, cst : rosetta.core.scoring.constraints.Constraint, object_comparison : bool) -> bool
Returns true iff the constraint was successfully found and removed.
- residue_pair_energy(...) from builtins.PyCapsule
- residue_pair_energy(self : rosetta.core.scoring.constraints.Constraints, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
will fail if Residues dont contain all the necessary atoms
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraints, xyz_func : core::scoring::func::XYZ_Func, scfxn : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraints, xyz_func : core::scoring::func::XYZ_Func, scfxn : rosetta.core.scoring.ScoreFunction) -> NoneType
- size(...) from builtins.PyCapsule
- size(rosetta.core.scoring.constraints.Constraints) -> int
|
class ConstraintsEnergy(rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) |
| | |
- Method resolution order:
- ConstraintsEnergy
- rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy
- rosetta.core.scoring.methods.LongRangeTwoBodyEnergy
- rosetta.core.scoring.methods.TwoBodyEnergy
- rosetta.core.scoring.methods.EnergyMethod
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(handle) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.core.scoring.constraints.ConstraintsEnergy, : rosetta.core.scoring.constraints.ConstraintsEnergy) -> rosetta.core.scoring.constraints.ConstraintsEnergy
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.ConstraintsEnergy) -> rosetta.core.scoring.methods.EnergyMethod
- defines_high_order_terms(...) from builtins.PyCapsule
- defines_high_order_terms(self : rosetta.core.scoring.constraints.ConstraintsEnergy, : 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).
- defines_intrares_dof_derivatives(...) from builtins.PyCapsule
- defines_intrares_dof_derivatives(self : rosetta.core.scoring.constraints.ConstraintsEnergy, p : 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.
- defines_intrares_energy(...) from builtins.PyCapsule
- defines_intrares_energy(self : rosetta.core.scoring.constraints.ConstraintsEnergy, weights : rosetta.core.scoring.EMapVector) -> bool
- defines_residue_pair_energy(...) from builtins.PyCapsule
- defines_residue_pair_energy(self : rosetta.core.scoring.constraints.ConstraintsEnergy, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool
Interface from the LongRangeTwoBodyEnery base class; returns "true" if there's any non-zero
or potentially non-zero interaction between a pair of residues in a pose.
- defines_score_for_residue_pair(...) from builtins.PyCapsule
- defines_score_for_residue_pair(self : rosetta.core.scoring.constraints.ConstraintsEnergy, res1 : rosetta.core.conformation.Residue, res2 : 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.
- eval_atom_derivative(...) from builtins.PyCapsule
- eval_atom_derivative(self : rosetta.core.scoring.constraints.ConstraintsEnergy, id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, : ObjexxFCL::FArray1D<int>, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType
called during gradient-based minimization inside dfunc
F1 and F2 are not zeroed -- contributions from this atom are
just summed in
- eval_dof_derivative(...) from builtins.PyCapsule
- eval_dof_derivative(self : rosetta.core.scoring.constraints.ConstraintsEnergy, id : rosetta.core.id.DOF_ID, tor : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, scorefxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector) -> float
Evaluate dof derivatives when DOF_constraints are in use
- eval_intrares_derivatives(...) from builtins.PyCapsule
- eval_intrares_derivatives(self : rosetta.core.scoring.constraints.ConstraintsEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType
- eval_intrares_energy(...) from builtins.PyCapsule
- eval_intrares_energy(self : rosetta.core.scoring.constraints.ConstraintsEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType
Evaluate the intra-residue constraint energy for a given residue
- eval_intrares_energy_ext(...) from builtins.PyCapsule
- eval_intrares_energy_ext(self : rosetta.core.scoring.constraints.ConstraintsEnergy, rsd : rosetta.core.conformation.Residue, data_cache : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType
Evaluate the intra-residue energies using ConstraintCOPs cached in the data_cache object
- eval_intraresidue_dof_derivative(...) from builtins.PyCapsule
- eval_intraresidue_dof_derivative(self : rosetta.core.scoring.constraints.ConstraintsEnergy, rsd : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResSingleMinimizationData, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : 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.
- eval_residue_pair_derivatives(...) from builtins.PyCapsule
- eval_residue_pair_derivatives(self : rosetta.core.scoring.constraints.ConstraintsEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, : rosetta.core.scoring.ResSingleMinimizationData, : rosetta.core.scoring.ResSingleMinimizationData, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, weights : rosetta.core.scoring.EMapVector, r1_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs : rosetta.utility.vector1_core_scoring_DerivVectorPair) -> NoneType
- finalize_total_energy(...) from builtins.PyCapsule
- finalize_total_energy(self : rosetta.core.scoring.constraints.ConstraintsEnergy, pose : rosetta.core.pose.Pose, : rosetta.core.scoring.ScoreFunction, totals : rosetta.core.scoring.EMapVector) -> NoneType
called at the end of energy evaluation
- indicate_required_context_graphs(...) from builtins.PyCapsule
- indicate_required_context_graphs(self : rosetta.core.scoring.constraints.ConstraintsEnergy, : rosetta.utility.vector1_bool) -> NoneType
- long_range_type(...) from builtins.PyCapsule
- long_range_type(rosetta.core.scoring.constraints.ConstraintsEnergy) -> 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
- minimize_in_whole_structure_context(...) from builtins.PyCapsule
- minimize_in_whole_structure_context(self : rosetta.core.scoring.constraints.ConstraintsEnergy, : rosetta.core.pose.Pose) -> bool
//////////////////////////////////////////////////////////////////////////
- prepare_constraints_energy_container(...) from builtins.PyCapsule
- prepare_constraints_energy_container(self : rosetta.core.scoring.constraints.ConstraintsEnergy, pose : rosetta.core.pose.Pose) -> NoneType
- requires_a_setup_for_derivatives_for_residue_opportunity(...) from builtins.PyCapsule
- requires_a_setup_for_derivatives_for_residue_opportunity(self : rosetta.core.scoring.constraints.ConstraintsEnergy, pose : 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.
- requires_a_setup_for_derivatives_for_residue_pair_opportunity(...) from builtins.PyCapsule
- requires_a_setup_for_derivatives_for_residue_pair_opportunity(self : rosetta.core.scoring.constraints.ConstraintsEnergy, pose : rosetta.core.pose.Pose) -> bool
Ask for the opportunity to setup for derivative evaluation
- requires_a_setup_for_scoring_for_residue_opportunity(...) from builtins.PyCapsule
- requires_a_setup_for_scoring_for_residue_opportunity(self : rosetta.core.scoring.constraints.ConstraintsEnergy, pose : rosetta.core.pose.Pose) -> bool
Ask for the opportunity to setup for scoring for evaluating 1-body constraints
- requires_a_setup_for_scoring_for_residue_pair_opportunity(...) from builtins.PyCapsule
- requires_a_setup_for_scoring_for_residue_pair_opportunity(self : rosetta.core.scoring.constraints.ConstraintsEnergy, pose : rosetta.core.pose.Pose) -> bool
Request the opportunity to setup for scoring
- residue_pair_energy(...) from builtins.PyCapsule
- residue_pair_energy(self : rosetta.core.scoring.constraints.ConstraintsEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType
- residue_pair_energy_ext(...) from builtins.PyCapsule
- residue_pair_energy_ext(self : rosetta.core.scoring.constraints.ConstraintsEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, min_data : rosetta.core.scoring.ResPairMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType
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.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.ConstraintsEnergy, pose : rosetta.core.pose.Pose, scfxn : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_derivatives_for_residue(...) from builtins.PyCapsule
- setup_for_derivatives_for_residue(self : rosetta.core.scoring.constraints.ConstraintsEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType
Do any setup work necessary before evaluating the derivatives for this residue
- setup_for_derivatives_for_residue_pair(...) from builtins.PyCapsule
- setup_for_derivatives_for_residue_pair(self : rosetta.core.scoring.constraints.ConstraintsEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType
Do any setup work necessary before evaluating the derivatives for this residue pair
- setup_for_minimizing_for_residue(...) from builtins.PyCapsule
- setup_for_minimizing_for_residue(self : rosetta.core.scoring.constraints.ConstraintsEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res_data_cache : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType
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.
- setup_for_minimizing_for_residue_pair(...) from builtins.PyCapsule
- setup_for_minimizing_for_residue_pair(self : rosetta.core.scoring.constraints.ConstraintsEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, minmap : rosetta.core.kinematics.MinimizerMapBase, res1_data_cache : rosetta.core.scoring.ResSingleMinimizationData, res2_data_cache : rosetta.core.scoring.ResSingleMinimizationData, respair_data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType
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
- setup_for_packing(...) from builtins.PyCapsule
- setup_for_packing(self : rosetta.core.scoring.constraints.ConstraintsEnergy, pose : rosetta.core.pose.Pose, residues_repacking : rosetta.utility.vector1_bool, residues_designing : rosetta.utility.vector1_bool) -> NoneType
Make sure that the ConstraintsEnergyContainer is ready for packing.
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.ConstraintsEnergy, pose : rosetta.core.pose.Pose, scfxn : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring_for_residue(...) from builtins.PyCapsule
- setup_for_scoring_for_residue(self : rosetta.core.scoring.constraints.ConstraintsEnergy, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, min_data : rosetta.core.scoring.ResSingleMinimizationData) -> NoneType
Allow the component constraints to setup for scoring for a particular residue
- setup_for_scoring_for_residue_pair(...) from builtins.PyCapsule
- setup_for_scoring_for_residue_pair(self : rosetta.core.scoring.constraints.ConstraintsEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, minsingle_data1 : rosetta.core.scoring.ResSingleMinimizationData, minsingle_data2 : rosetta.core.scoring.ResSingleMinimizationData, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, data_cache : rosetta.core.scoring.ResPairMinimizationData) -> NoneType
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
- use_extended_intrares_energy_interface(...) from builtins.PyCapsule
- use_extended_intrares_energy_interface(rosetta.core.scoring.constraints.ConstraintsEnergy) -> bool
request of minimization routines that they use the extended intraresidue energy
interface
- use_extended_residue_pair_energy_interface(...) from builtins.PyCapsule
- use_extended_residue_pair_energy_interface(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
- version(...) from builtins.PyCapsule
- version(rosetta.core.scoring.constraints.ConstraintsEnergy) -> int
Methods inherited from rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy:
- method_type(...) from builtins.PyCapsule
- method_type(rosetta.core.scoring.methods.ContextIndependentLRTwoBodyEnergy) -> rosetta.core.scoring.methods.EnergyMethodType
Methods inherited from rosetta.core.scoring.methods.TwoBodyEnergy:
- backbone_backbone_energy(...) from builtins.PyCapsule
- backbone_backbone_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType
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.
- backbone_sidechain_energy(...) from builtins.PyCapsule
- backbone_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType
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.
- bump_energy_backbone(...) from builtins.PyCapsule
- bump_energy_backbone(self : rosetta.core.scoring.methods.TwoBodyEnergy, : rosetta.core.conformation.Residue, : rosetta.core.conformation.Residue, : rosetta.core.pose.Pose, : rosetta.core.scoring.ScoreFunction, : rosetta.core.scoring.EMapVector) -> NoneType
- bump_energy_full(...) from builtins.PyCapsule
- bump_energy_full(self : rosetta.core.scoring.methods.TwoBodyEnergy, : rosetta.core.conformation.Residue, : rosetta.core.conformation.Residue, : rosetta.core.pose.Pose, : rosetta.core.scoring.ScoreFunction, : rosetta.core.scoring.EMapVector) -> NoneType
- defines_intrares_energy_for_residue(...) from builtins.PyCapsule
- defines_intrares_energy_for_residue(self : rosetta.core.scoring.methods.TwoBodyEnergy, res : 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.
- evaluate_rotamer_background_energies(...) from builtins.PyCapsule
- evaluate_rotamer_background_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_vector : rosetta.utility.vector1_float) -> NoneType
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
- evaluate_rotamer_background_energy_maps(...) from builtins.PyCapsule
- evaluate_rotamer_background_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, residue : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType
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
- evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule
- evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, energies : rosetta.utility.vector1_float) -> NoneType
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.
- evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule
- evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.methods.TwoBodyEnergy, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType
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.
- evaluate_rotamer_pair_energies(...) from builtins.PyCapsule
- evaluate_rotamer_pair_energies(self : rosetta.core.scoring.methods.TwoBodyEnergy, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, weights : rosetta.core.scoring.EMapVector, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType
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.
- sidechain_sidechain_energy(...) from builtins.PyCapsule
- sidechain_sidechain_energy(self : rosetta.core.scoring.methods.TwoBodyEnergy, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, sfxn : rosetta.core.scoring.ScoreFunction, emap : rosetta.core.scoring.EMapVector) -> NoneType
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.
Methods inherited from rosetta.core.scoring.methods.EnergyMethod:
- finalize_after_derivatives(...) from builtins.PyCapsule
- finalize_after_derivatives(self : rosetta.core.scoring.methods.EnergyMethod, : rosetta.core.pose.Pose, : rosetta.core.scoring.ScoreFunction) -> NoneType
called at the end of derivatives evaluation
- prepare_rotamers_for_packing(...) from builtins.PyCapsule
- prepare_rotamers_for_packing(self : rosetta.core.scoring.methods.EnergyMethod, : rosetta.core.pose.Pose, : rosetta.core.conformation.RotamerSetBase) -> NoneType
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.
- score_types(...) from builtins.PyCapsule
- score_types(rosetta.core.scoring.methods.EnergyMethod) -> rosetta.utility.vector1_core_scoring_ScoreType
Returns the score types that this energy method computes.
- setup_for_minimizing(...) from builtins.PyCapsule
- setup_for_minimizing(self : rosetta.core.scoring.methods.EnergyMethod, : rosetta.core.pose.Pose, : rosetta.core.scoring.ScoreFunction, : rosetta.core.kinematics.MinimizerMapBase) -> NoneType
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.
- update_residue_for_packing(...) from builtins.PyCapsule
- update_residue_for_packing(self : rosetta.core.scoring.methods.EnergyMethod, : rosetta.core.pose.Pose, resid : int) -> NoneType
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.
|
class CoordinateConstraint(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
|
| |
- Method resolution order:
- CoordinateConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.CoordinateConstraint, other_cst : rosetta.core.scoring.constraints.Constraint) -> bool
possibility to do object comparison instead
of pointer comparison
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(handle, rosetta.core.scoring.constraints.CoordinateConstraint) -> NoneType
3. __init__(handle, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.numeric.xyzVector_double_t, rosetta.core.scoring.func.Func) -> NoneType
doc
4. __init__(self : handle, a1 : rosetta.core.id.AtomID, fixed_atom_in : rosetta.core.id.AtomID, xyz_target_in : rosetta.numeric.xyzVector_double_t, func : rosetta.core.scoring.func.Func, scotype : rosetta.core.scoring.ScoreType) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.CoordinateConstraint, n : int) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(*args, **kwargs)
Overloaded function.
1. clone(rosetta.core.scoring.constraints.CoordinateConstraint) -> rosetta.core.scoring.constraints.Constraint
2. clone(self : rosetta.core.scoring.constraints.CoordinateConstraint, : rosetta.core.scoring.func.Func) -> rosetta.core.scoring.constraints.Constraint
- dist(...) from builtins.PyCapsule
- dist(self : rosetta.core.scoring.constraints.CoordinateConstraint, pose : rosetta.core.pose.Pose) -> float
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.CoordinateConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.CoordinateConstraint) -> int
- non_virtual_score(...) from builtins.PyCapsule
- non_virtual_score(self : rosetta.core.scoring.constraints.CoordinateConstraint, xyz : rosetta.numeric.xyzVector_double_t) -> float
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.CoordinateConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.CoordinateConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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.
2. remapped_clone(self : rosetta.core.scoring.constraints.CoordinateConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.CoordinateConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.CoordinateConstraint, xyz : core::scoring::func::XYZ_Func, : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.CoordinateConstraint, : rosetta.core.pose.Pose) -> NoneType
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.CoordinateConstraint) -> str
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class CstEnergyContainer(rosetta.core.scoring.LREnergyContainer) |
| | |
- Method resolution order:
- CstEnergyContainer
- rosetta.core.scoring.LREnergyContainer
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(self : handle, : rosetta.core.pose.Pose) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- any_neighbors_for_residue(...) from builtins.PyCapsule
- any_neighbors_for_residue(self : rosetta.core.scoring.constraints.CstEnergyContainer, resid : int) -> bool
- any_upper_neighbors_for_residue(...) from builtins.PyCapsule
- any_upper_neighbors_for_residue(self : rosetta.core.scoring.constraints.CstEnergyContainer, resid : int) -> bool
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.core.scoring.constraints.CstEnergyContainer, : rosetta.core.scoring.constraints.CstEnergyContainer) -> rosetta.core.scoring.constraints.CstEnergyContainer
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.CstEnergyContainer) -> rosetta.core.scoring.LREnergyContainer
- const_neighbor_iterator_begin(...) from builtins.PyCapsule
- const_neighbor_iterator_begin(self : rosetta.core.scoring.constraints.CstEnergyContainer, resid : int) -> rosetta.core.scoring.ResidueNeighborConstIterator
- const_neighbor_iterator_end(...) from builtins.PyCapsule
- const_neighbor_iterator_end(self : rosetta.core.scoring.constraints.CstEnergyContainer, resid : int) -> rosetta.core.scoring.ResidueNeighborConstIterator
- const_upper_neighbor_iterator_begin(...) from builtins.PyCapsule
- const_upper_neighbor_iterator_begin(self : rosetta.core.scoring.constraints.CstEnergyContainer, resid : int) -> rosetta.core.scoring.ResidueNeighborConstIterator
- const_upper_neighbor_iterator_end(...) from builtins.PyCapsule
- const_upper_neighbor_iterator_end(self : rosetta.core.scoring.constraints.CstEnergyContainer, resid : int) -> rosetta.core.scoring.ResidueNeighborConstIterator
- empty(...) from builtins.PyCapsule
- empty(rosetta.core.scoring.constraints.CstEnergyContainer) -> bool
- matches(...) from builtins.PyCapsule
- matches(self : 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?
- neighbor_iterator_begin(...) from builtins.PyCapsule
- neighbor_iterator_begin(self : rosetta.core.scoring.constraints.CstEnergyContainer, resid : int) -> rosetta.core.scoring.ResidueNeighborIterator
- neighbor_iterator_end(...) from builtins.PyCapsule
- neighbor_iterator_end(self : rosetta.core.scoring.constraints.CstEnergyContainer, resid : int) -> rosetta.core.scoring.ResidueNeighborIterator
- set_num_nodes(...) from builtins.PyCapsule
- set_num_nodes(self : rosetta.core.scoring.constraints.CstEnergyContainer, : int) -> NoneType
- upper_neighbor_iterator_begin(...) from builtins.PyCapsule
- upper_neighbor_iterator_begin(self : rosetta.core.scoring.constraints.CstEnergyContainer, resid : int) -> rosetta.core.scoring.ResidueNeighborIterator
- upper_neighbor_iterator_end(...) from builtins.PyCapsule
- upper_neighbor_iterator_end(self : rosetta.core.scoring.constraints.CstEnergyContainer, resid : int) -> rosetta.core.scoring.ResidueNeighborIterator
|
class DOF_Constraint(builtins.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.
|
| |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle, rosetta.core.id.DOF_ID, rosetta.core.scoring.func.Func) -> NoneType
doc
2. __init__(self : handle, id : rosetta.core.id.DOF_ID, func : rosetta.core.scoring.func.Func, t : rosetta.core.scoring.ScoreType) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- dfunc(...) from builtins.PyCapsule
- dfunc(self : rosetta.core.scoring.constraints.DOF_Constraint, val : float) -> float
Returns the func::Function Derivative
- dof_id(...) from builtins.PyCapsule
- dof_id(rosetta.core.scoring.constraints.DOF_Constraint) -> rosetta.core.id.DOF_ID
Returns the ScoreType
- func(...) from builtins.PyCapsule
- func(self : rosetta.core.scoring.constraints.DOF_Constraint, val : float) -> float
Returns the func::Function
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.DOF_Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType
|
class DihedralConstraint(Constraint) |
| |
constraint on dihedral angle formed by 4 points
|
| |
- Method resolution order:
- DihedralConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.DihedralConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
possibility to compare constraint according to data
and not just pointers
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.scoring.func.Func) -> NoneType
doc
2. __init__(self : handle, a1 : rosetta.core.id.AtomID, a2 : rosetta.core.id.AtomID, a3 : rosetta.core.id.AtomID, a4 : rosetta.core.id.AtomID, func : rosetta.core.scoring.func.Func, scotype : rosetta.core.scoring.ScoreType) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.DihedralConstraint, n : int) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.DihedralConstraint) -> rosetta.core.scoring.constraints.Constraint
Perform a deep clone by cloning the func_ pointer held by this %DihedralConstraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.DihedralConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.DihedralConstraint) -> rosetta.core.scoring.func.Func
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.DihedralConstraint) -> int
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.DihedralConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.DihedralConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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.
2. remapped_clone(self : rosetta.core.scoring.constraints.DihedralConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.DihedralConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(*args, **kwargs)
Overloaded function.
1. score(self : rosetta.core.scoring.constraints.DihedralConstraint, xyz1 : rosetta.numeric.xyzVector_double_t, xyz2 : rosetta.numeric.xyzVector_double_t, xyz3 : rosetta.numeric.xyzVector_double_t, xyz4 : rosetta.numeric.xyzVector_double_t) -> float
2. score(self : rosetta.core.scoring.constraints.DihedralConstraint, xyz : core::scoring::func::XYZ_Func, : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
3. score(self : rosetta.core.scoring.constraints.DihedralConstraint, conformation : rosetta.core.conformation.Conformation) -> float
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.DihedralConstraint) -> str
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class DihedralPairConstraint(Constraint) |
| |
constraint on dihedral angle formed by 4 points
|
| |
- Method resolution order:
- DihedralPairConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.DihedralPairConstraint, rhs : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.scoring.func.Func) -> NoneType
doc
2. __init__(self : handle, a1 : rosetta.core.id.AtomID, a2 : rosetta.core.id.AtomID, a3 : rosetta.core.id.AtomID, a4 : rosetta.core.id.AtomID, b1 : rosetta.core.id.AtomID, b2 : rosetta.core.id.AtomID, b3 : rosetta.core.id.AtomID, b4 : rosetta.core.id.AtomID, func : rosetta.core.scoring.func.Func, scotype : rosetta.core.scoring.ScoreType) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.DihedralPairConstraint, n : int) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.DihedralPairConstraint) -> rosetta.core.scoring.constraints.Constraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.DihedralPairConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.DihedralPairConstraint) -> int
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.DihedralPairConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.DihedralPairConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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.
2. remapped_clone(self : rosetta.core.scoring.constraints.DihedralPairConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.DihedralPairConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(*args, **kwargs)
Overloaded function.
1. score(self : rosetta.core.scoring.constraints.DihedralPairConstraint, X1 : rosetta.numeric.xyzVector_double_t, X2 : rosetta.numeric.xyzVector_double_t, X3 : rosetta.numeric.xyzVector_double_t, X4 : rosetta.numeric.xyzVector_double_t, Y1 : rosetta.numeric.xyzVector_double_t, Y2 : rosetta.numeric.xyzVector_double_t, Y3 : rosetta.numeric.xyzVector_double_t, Y4 : rosetta.numeric.xyzVector_double_t) -> float
2. score(self : rosetta.core.scoring.constraints.DihedralPairConstraint, xyz : core::scoring::func::XYZ_Func, : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
3. score(self : rosetta.core.scoring.constraints.DihedralPairConstraint, conformation : rosetta.core.conformation.Conformation) -> float
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.DihedralPairConstraint) -> str
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class DistancePairConstraint(Constraint) |
| |
constraint on CA distance
|
| |
- Method resolution order:
- DistancePairConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.DistancePairConstraint, rhs : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.id.AtomID, rosetta.core.scoring.func.Func) -> NoneType
doc
2. __init__(self : handle, a1 : rosetta.core.id.AtomID, a2 : rosetta.core.id.AtomID, b1 : rosetta.core.id.AtomID, b2 : rosetta.core.id.AtomID, func : rosetta.core.scoring.func.Func, scotype : rosetta.core.scoring.ScoreType) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.DistancePairConstraint, n : int) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.DistancePairConstraint) -> rosetta.core.scoring.constraints.Constraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.DistancePairConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.DistancePairConstraint) -> int
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.DistancePairConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.DistancePairConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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.
2. remapped_clone(self : rosetta.core.scoring.constraints.DistancePairConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.DistancePairConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(*args, **kwargs)
Overloaded function.
1. score(self : rosetta.core.scoring.constraints.DistancePairConstraint, X1 : rosetta.numeric.xyzVector_double_t, X2 : rosetta.numeric.xyzVector_double_t, Y1 : rosetta.numeric.xyzVector_double_t, Y2 : rosetta.numeric.xyzVector_double_t) -> float
2. score(self : rosetta.core.scoring.constraints.DistancePairConstraint, xyz : core::scoring::func::XYZ_Func, : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
3. score(self : rosetta.core.scoring.constraints.DistancePairConstraint, conformation : rosetta.core.conformation.Conformation) -> float
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.DistancePairConstraint) -> str
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class FabConstraint(MultiConstraint) |
| | |
- Method resolution order:
- FabConstraint
- MultiConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.FabConstraint, rhs : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(self : handle, cst_in : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- calc_penalty_vec(...) from builtins.PyCapsule
- calc_penalty_vec(self : rosetta.core.scoring.constraints.FabConstraint, start_res : int, stop_res : int, res1 : rosetta.utility.vector1_unsigned_long, res2 : rosetta.utility.vector1_unsigned_long) -> rosetta.utility.vector1_double
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.FabConstraint) -> rosetta.core.scoring.constraints.Constraint
- pose_res_no(...) from builtins.PyCapsule
- pose_res_no(self : rosetta.core.scoring.constraints.FabConstraint, pose : rosetta.core.pose.Pose, tempres : str) -> int
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.FabConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- setup_csts(...) from builtins.PyCapsule
- setup_csts(self : rosetta.core.scoring.constraints.FabConstraint, pose : rosetta.core.pose.Pose, res1 : rosetta.utility.vector1_unsigned_long, res2 : rosetta.utility.vector1_unsigned_long, antchains : str) -> NoneType
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.FabConstraint) -> str
Methods inherited from MultiConstraint:
- add_individual_constraint(...) from builtins.PyCapsule
- add_individual_constraint(self : rosetta.core.scoring.constraints.MultiConstraint, cst_in : rosetta.core.scoring.constraints.Constraint) -> NoneType
add individual constraint into MultiConstraint
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.MultiConstraint, n : int) -> rosetta.core.id.AtomID
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- empty_clone(...) from builtins.PyCapsule
- empty_clone(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.core.scoring.constraints.MultiConstraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.MultiConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
compute atom deriv
- member_constraints(...) from builtins.PyCapsule
- member_constraints(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.MultiConstraint) -> int
number of atoms involved in this MultiConstraint container
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.MultiConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose) -> rosetta.core.scoring.constraints.Constraint
2. remapped_clone(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.utility.vector1_unsigned_long
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.MultiConstraint, xyz_func : core::scoring::func::XYZ_Func, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
compute score
- set_effective_sequence_separation(...) from builtins.PyCapsule
- set_effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, setting : int) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.MultiConstraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- size(...) from builtins.PyCapsule
- size(rosetta.core.scoring.constraints.MultiConstraint) -> int
number of constraints that are held by this %MultiConstraint
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class KofNConstraint(MultiConstraint) |
| | |
- Method resolution order:
- KofNConstraint
- MultiConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.KofNConstraint, rhs : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
doc
2. __init__(self : handle, K : int) -> NoneType
3. __init__(handle, rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) -> NoneType
doc
4. __init__(self : handle, cst_in : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, K : int) -> NoneType
5. __init__(handle, rosetta.core.scoring.constraints.KofNConstraint) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- active_constraints(...) from builtins.PyCapsule
- active_constraints(rosetta.core.scoring.constraints.KofNConstraint) -> rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t
- calculate_total_cst_score(...) from builtins.PyCapsule
- calculate_total_cst_score(self : rosetta.core.scoring.constraints.KofNConstraint, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> float
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.KofNConstraint) -> rosetta.core.scoring.constraints.Constraint
- empty_clone(...) from builtins.PyCapsule
- empty_clone(rosetta.core.scoring.constraints.KofNConstraint) -> rosetta.core.scoring.constraints.MultiConstraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.KofNConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
compute atom deriv
- getK(...) from builtins.PyCapsule
- getK(rosetta.core.scoring.constraints.KofNConstraint) -> int
- init_cst_score_types(...) from builtins.PyCapsule
- init_cst_score_types(rosetta.core.scoring.constraints.KofNConstraint) -> NoneType
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.KofNConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.KofNConstraint, rhs : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.KofNConstraint, xyz_func : core::scoring::func::XYZ_Func, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
compute score
- setK(...) from builtins.PyCapsule
- setK(self : rosetta.core.scoring.constraints.KofNConstraint, K : int) -> NoneType
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.KofNConstraint) -> str
Methods inherited from MultiConstraint:
- add_individual_constraint(...) from builtins.PyCapsule
- add_individual_constraint(self : rosetta.core.scoring.constraints.MultiConstraint, cst_in : rosetta.core.scoring.constraints.Constraint) -> NoneType
add individual constraint into MultiConstraint
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.MultiConstraint, n : int) -> rosetta.core.id.AtomID
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- member_constraints(...) from builtins.PyCapsule
- member_constraints(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.MultiConstraint) -> int
number of atoms involved in this MultiConstraint container
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose) -> rosetta.core.scoring.constraints.Constraint
2. remapped_clone(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.utility.vector1_unsigned_long
- set_effective_sequence_separation(...) from builtins.PyCapsule
- set_effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, setting : int) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.MultiConstraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- size(...) from builtins.PyCapsule
- size(rosetta.core.scoring.constraints.MultiConstraint) -> int
number of constraints that are held by this %MultiConstraint
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class LocalCoordinateConstraint(Constraint) |
| | |
- Method resolution order:
- LocalCoordinateConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.LocalCoordinateConstraint, rhs : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(handle, rosetta.core.id.AtomID, rosetta.core.id.StubID, rosetta.numeric.xyzVector_double_t, rosetta.core.scoring.func.Func) -> NoneType
doc
3. __init__(self : handle, a1 : rosetta.core.id.AtomID, fixed_stub_in : rosetta.core.id.StubID, xyz_target_in : rosetta.numeric.xyzVector_double_t, func : rosetta.core.scoring.func.Func, scotype : rosetta.core.scoring.ScoreType) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.LocalCoordinateConstraint, n : int) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.LocalCoordinateConstraint) -> rosetta.core.scoring.constraints.Constraint
- dist(...) from builtins.PyCapsule
- dist(self : rosetta.core.scoring.constraints.LocalCoordinateConstraint, pose : rosetta.core.pose.Pose) -> float
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.LocalCoordinateConstraint, atom : rosetta.core.id.AtomID, xyz : rosetta.core.scoring.func.XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.LocalCoordinateConstraint) -> int
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.LocalCoordinateConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.LocalCoordinateConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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.
2. remapped_clone(self : rosetta.core.scoring.constraints.LocalCoordinateConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.LocalCoordinateConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(*args, **kwargs)
Overloaded function.
1. score(self : rosetta.core.scoring.constraints.LocalCoordinateConstraint, xyz : rosetta.numeric.xyzVector_double_t, s1 : rosetta.numeric.xyzVector_double_t, s2 : rosetta.numeric.xyzVector_double_t, s3 : rosetta.numeric.xyzVector_double_t) -> float
2. score(self : rosetta.core.scoring.constraints.LocalCoordinateConstraint, xyz : rosetta.core.scoring.func.XYZ_Func, : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
- set_fixed_stub(...) from builtins.PyCapsule
- set_fixed_stub(self : rosetta.core.scoring.constraints.LocalCoordinateConstraint, new_stub : rosetta.core.id.StubID) -> NoneType
- set_xyz_target(...) from builtins.PyCapsule
- set_xyz_target(self : rosetta.core.scoring.constraints.LocalCoordinateConstraint, xyz_in : rosetta.numeric.xyzVector_double_t, local_frame_pose : rosetta.core.pose.Pose) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.LocalCoordinateConstraint, : rosetta.core.pose.Pose) -> NoneType
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.LocalCoordinateConstraint) -> str
- xyz_target(...) from builtins.PyCapsule
- xyz_target(self : rosetta.core.scoring.constraints.LocalCoordinateConstraint, local_frame_pose : rosetta.core.pose.Pose) -> rosetta.numeric.xyzVector_double_t
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class MultiConstraint(Constraint) |
| | |
- Method resolution order:
- MultiConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.MultiConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
possibility to compare constraint according to data
and not just pointers
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
doc
2. __init__(self : handle, t : rosetta.core.scoring.ScoreType) -> NoneType
3. __init__(handle, rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) -> NoneType
doc
4. __init__(self : handle, cst_in : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t, t : rosetta.core.scoring.ScoreType) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- add_individual_constraint(...) from builtins.PyCapsule
- add_individual_constraint(self : rosetta.core.scoring.constraints.MultiConstraint, cst_in : rosetta.core.scoring.constraints.Constraint) -> NoneType
add individual constraint into MultiConstraint
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.MultiConstraint, n : int) -> rosetta.core.id.AtomID
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.core.scoring.constraints.Constraint
Creates a deep copy of this %MultiConstaint, cloning all constraints that it holds.
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- empty_clone(...) from builtins.PyCapsule
- empty_clone(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.core.scoring.constraints.MultiConstraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.MultiConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
compute atom deriv
- member_constraints(...) from builtins.PyCapsule
- member_constraints(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.MultiConstraint) -> int
number of atoms involved in this MultiConstraint container
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.MultiConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose) -> rosetta.core.scoring.constraints.Constraint
2. remapped_clone(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.utility.vector1_unsigned_long
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.MultiConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.MultiConstraint, xyz_func : core::scoring::func::XYZ_Func, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
compute score
- set_effective_sequence_separation(...) from builtins.PyCapsule
- set_effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, setting : int) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.MultiConstraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- size(...) from builtins.PyCapsule
- size(rosetta.core.scoring.constraints.MultiConstraint) -> int
number of constraints that are held by this %MultiConstraint
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.MultiConstraint) -> str
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class NamedAngleConstraint(AngleConstraint) |
| | |
- Method resolution order:
- NamedAngleConstraint
- AngleConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.NamedAngleConstraint, rhs : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle, rosetta.core.id.NamedAtomID, rosetta.core.id.NamedAtomID, rosetta.core.id.NamedAtomID, rosetta.core.scoring.func.Func) -> NoneType
doc
2. __init__(self : handle, a1 : rosetta.core.id.NamedAtomID, a2 : rosetta.core.id.NamedAtomID, a3 : rosetta.core.id.NamedAtomID, func : rosetta.core.scoring.func.Func, scoretype : rosetta.core.scoring.ScoreType) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.NamedAngleConstraint) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.NamedAngleConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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.
2. remapped_clone(self : rosetta.core.scoring.constraints.NamedAngleConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.NamedAngleConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.NamedAngleConstraint, : rosetta.core.scoring.func.XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.NamedAngleConstraint) -> str
Methods inherited from AngleConstraint:
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.AngleConstraint, n : int) -> rosetta.core.id.AtomID
return AtomID for atom 1,2,3
- atom1(...) from builtins.PyCapsule
- atom1(rosetta.core.scoring.constraints.AngleConstraint) -> rosetta.core.id.AtomID
- atom2(...) from builtins.PyCapsule
- atom2(rosetta.core.scoring.constraints.AngleConstraint) -> rosetta.core.id.AtomID
- atom3(...) from builtins.PyCapsule
- atom3(rosetta.core.scoring.constraints.AngleConstraint) -> rosetta.core.id.AtomID
- dfunc(...) from builtins.PyCapsule
- dfunc(self : rosetta.core.scoring.constraints.AngleConstraint, theta : float) -> float
evaluate dfunc at theta
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.AngleConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
compute atom deriv
- func(...) from builtins.PyCapsule
- func(self : rosetta.core.scoring.constraints.AngleConstraint, theta : float) -> float
evaluate func at theta
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.AngleConstraint) -> rosetta.core.scoring.func.Func
- helper(...) from builtins.PyCapsule
- helper(M : rosetta.numeric.xyzVector_double_t, w : rosetta.numeric.xyzVector_double_t, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.AngleConstraint) -> int
number of atoms --- always 3 for angles
- p1_deriv(...) from builtins.PyCapsule
- p1_deriv(self : rosetta.core.scoring.constraints.AngleConstraint, p1 : rosetta.numeric.xyzVector_double_t, p2 : rosetta.numeric.xyzVector_double_t, p3 : rosetta.numeric.xyzVector_double_t, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType
- p1_theta_deriv(...) from builtins.PyCapsule
- p1_theta_deriv(p1 : rosetta.numeric.xyzVector_double_t, p2 : rosetta.numeric.xyzVector_double_t, p3 : rosetta.numeric.xyzVector_double_t, f1 : rosetta.numeric.xyzVector_double_t, f2 : rosetta.numeric.xyzVector_double_t) -> NoneType
- p2_deriv(...) from builtins.PyCapsule
- p2_deriv(self : rosetta.core.scoring.constraints.AngleConstraint, p1 : rosetta.numeric.xyzVector_double_t, p2 : rosetta.numeric.xyzVector_double_t, p3 : rosetta.numeric.xyzVector_double_t, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.AngleConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- score(...) from builtins.PyCapsule
- score(*args, **kwargs)
Overloaded function.
1. score(self : rosetta.core.scoring.constraints.AngleConstraint, xyz1 : rosetta.numeric.xyzVector_double_t, xyz2 : rosetta.numeric.xyzVector_double_t, xyz3 : rosetta.numeric.xyzVector_double_t) -> float
compute score
2. score(self : rosetta.core.scoring.constraints.AngleConstraint, xyz : core::scoring::func::XYZ_Func, : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
compute score
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class NamedAtomPairConstraint(AtomPairConstraint) |
| | |
- Method resolution order:
- NamedAtomPairConstraint
- AtomPairConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.NamedAtomPairConstraint, rhs : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle, rosetta.core.id.NamedAtomID, rosetta.core.id.NamedAtomID, rosetta.core.scoring.func.Func) -> NoneType
doc
2. __init__(self : handle, a1 : rosetta.core.id.NamedAtomID, a2 : rosetta.core.id.NamedAtomID, func : rosetta.core.scoring.func.Func, scoretype : rosetta.core.scoring.ScoreType) -> NoneType
3. __init__(handle, rosetta.core.scoring.constraints.NamedAtomPairConstraint) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.NamedAtomPairConstraint) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.NamedAtomPairConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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.
2. remapped_clone(self : rosetta.core.scoring.constraints.NamedAtomPairConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.NamedAtomPairConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.NamedAtomPairConstraint, : rosetta.core.scoring.func.XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
Methods inherited from AtomPairConstraint:
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.AtomPairConstraint, n : int) -> rosetta.core.id.AtomID
- atom1(...) from builtins.PyCapsule
- atom1(rosetta.core.scoring.constraints.AtomPairConstraint) -> rosetta.core.id.AtomID
- atom2(...) from builtins.PyCapsule
- atom2(rosetta.core.scoring.constraints.AtomPairConstraint) -> rosetta.core.id.AtomID
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.AtomPairConstraint, pose : rosetta.core.pose.Pose) -> float
2. dist(self : rosetta.core.scoring.constraints.AtomPairConstraint, conformation : rosetta.core.conformation.Conformation) -> float
3. dist(self : rosetta.core.scoring.constraints.AtomPairConstraint, xyz : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.AtomPairConstraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.AtomPairConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.AtomPairConstraint) -> rosetta.core.scoring.func.Func
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.AtomPairConstraint) -> int
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.AtomPairConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- score(...) from builtins.PyCapsule
- score(*args, **kwargs)
Overloaded function.
1. score(self : rosetta.core.scoring.constraints.AtomPairConstraint, xyz1 : rosetta.numeric.xyzVector_double_t, xyz2 : rosetta.numeric.xyzVector_double_t) -> float
2. score(self : rosetta.core.scoring.constraints.AtomPairConstraint, xyz : core::scoring::func::XYZ_Func, : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
3. score(self : rosetta.core.scoring.constraints.AtomPairConstraint, pose : rosetta.core.pose.Pose) -> float
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.AtomPairConstraint) -> str
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class NamedDihedralConstraint(DihedralConstraint) |
| | |
- Method resolution order:
- NamedDihedralConstraint
- DihedralConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.NamedDihedralConstraint, rhs : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle, rosetta.core.id.NamedAtomID, rosetta.core.id.NamedAtomID, rosetta.core.id.NamedAtomID, rosetta.core.id.NamedAtomID, rosetta.core.scoring.func.Func) -> NoneType
doc
2. __init__(self : handle, a1 : rosetta.core.id.NamedAtomID, a2 : rosetta.core.id.NamedAtomID, a3 : rosetta.core.id.NamedAtomID, a4 : rosetta.core.id.NamedAtomID, func : rosetta.core.scoring.func.Func, scoretype : rosetta.core.scoring.ScoreType) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.NamedDihedralConstraint) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.NamedDihedralConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> 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.
2. remapped_clone(self : rosetta.core.scoring.constraints.NamedDihedralConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.NamedDihedralConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.NamedDihedralConstraint, xyz : rosetta.core.scoring.func.XYZ_Func, : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.NamedDihedralConstraint) -> str
Methods inherited from DihedralConstraint:
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.DihedralConstraint, n : int) -> rosetta.core.id.AtomID
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.DihedralConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.DihedralConstraint) -> rosetta.core.scoring.func.Func
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.DihedralConstraint) -> int
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.DihedralConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.Constraint) -> rosetta.utility.vector1_unsigned_long
Returns the pose numbers of the residues involved in this constraint, in no particular order.
Used in determining one-body/two-body/multi-body status.
For historical reasons, the default uses a simple protocol based on natoms()/atom() -
feel free to reimplement more efficiently.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class NonResidueTypeConstraint(Constraint) |
| |
This class favors a particular residue identity at a particular position by reducing its res_type energy.
|
| |
- Method resolution order:
- NonResidueTypeConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.NonResidueTypeConstraint, rhs : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(self : handle, pose : rosetta.core.pose.Pose, seqpos : int, non_native_residue_bonus : float) -> NoneType
2. __init__(self : handle, pose : rosetta.core.pose.Pose, seqpos : int, AAname : str, favor_non_native_bonus : float) -> NoneType
3. __init__(self : handle, seqpos : int, aa_in : str, name3_in : str, bonus_in : float) -> NoneType
4. __init__(handle, rosetta.core.scoring.constraints.NonResidueTypeConstraint) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.NonResidueTypeConstraint, : int) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.NonResidueTypeConstraint) -> rosetta.core.scoring.constraints.Constraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.NonResidueTypeConstraint, atom : rosetta.core.id.AtomID, xyz : rosetta.core.scoring.func.XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.NonResidueTypeConstraint) -> int
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.NonResidueTypeConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.NonResidueTypeConstraint) -> rosetta.utility.vector1_unsigned_long
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.NonResidueTypeConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.NonResidueTypeConstraint, xyz_func : rosetta.core.scoring.func.XYZ_Func, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.Constraint) -> str
Returns a unique string identified for this constraint. Used in several
places, including the ConstraintIO class.
|
class Obsolet_NamedAtomPairConstraint(builtins.object) |
| | |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(self : rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint, : rosetta.core.scoring.constraints.AtomPairConstraint, : rosetta.core.pose.Pose) -> NoneType
2. __init__(self : rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint, atom1 : rosetta.core.id.NamedAtomID, atom2 : rosetta.core.id.NamedAtomID, cst : rosetta.core.scoring.constraints.AtomPairConstraint) -> NoneType
3. __init__(self : rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint, : rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint) -> str
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint, : rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint) -> rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint
- atom1(...) from builtins.PyCapsule
- atom1(rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint) -> rosetta.core.id.NamedAtomID
- atom2(...) from builtins.PyCapsule
- atom2(rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint) -> rosetta.core.id.NamedAtomID
- mapto(...) from builtins.PyCapsule
- mapto(*args, **kwargs)
Overloaded function.
1. mapto(self : rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint, : rosetta.core.id.SequenceMapping, : rosetta.core.pose.Pose) -> rosetta.core.scoring.constraints.AtomPairConstraint
2. mapto(self : rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint, : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint
3. mapto(self : rosetta.core.scoring.constraints.Obsolet_NamedAtomPairConstraint, : rosetta.core.pose.Pose) -> rosetta.core.scoring.constraints.AtomPairConstraint
|
class OffsetPeriodicBoundFunc(BoundFunc) |
| |
a variant of the bound func that is periodic
|
| |
- Method resolution order:
- OffsetPeriodicBoundFunc
- BoundFunc
- rosetta.core.scoring.func.Func
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc, rhs : rosetta.core.scoring.func.Func) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(self : handle, lb : float, ub : float, sd : float, type : str, periodicity_in : float, offset_in : float) -> NoneType
2. __init__(handle, rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc, : rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc) -> rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc) -> rosetta.core.scoring.func.Func
- dfunc(...) from builtins.PyCapsule
- dfunc(self : rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc, x : float) -> float
- func(...) from builtins.PyCapsule
- func(self : rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc, x : float) -> float
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.OffsetPeriodicBoundFunc, rhs : rosetta.core.scoring.func.Func) -> bool
Methods inherited from BoundFunc:
- lb(...) from builtins.PyCapsule
- lb(rosetta.core.scoring.constraints.BoundFunc) -> float
- rswitch(...) from builtins.PyCapsule
- rswitch(rosetta.core.scoring.constraints.BoundFunc) -> float
- sd(...) from builtins.PyCapsule
- sd(rosetta.core.scoring.constraints.BoundFunc) -> float
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.BoundFunc) -> str
- ub(...) from builtins.PyCapsule
- ub(rosetta.core.scoring.constraints.BoundFunc) -> float
Methods inherited from rosetta.core.scoring.func.Func:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.func.Func, other : rosetta.core.scoring.func.Func) -> bool
inequality operator -- simply the negation of the (virtual) equality operator
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.func.Func) -> str
- estimate_dfunc(...) from builtins.PyCapsule
- estimate_dfunc(*args, **kwargs)
Overloaded function.
1. estimate_dfunc(self : 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).
2. estimate_dfunc(self : 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).
|
class PeriodicBoundFunc(BoundFunc) |
| |
a variant of the bound func that is periodic
|
| |
- Method resolution order:
- PeriodicBoundFunc
- BoundFunc
- rosetta.core.scoring.func.Func
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.PeriodicBoundFunc, rhs : rosetta.core.scoring.func.Func) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(self : handle, lb : float, ub : float, sd : float, type : str, periodicity_in : float) -> NoneType
2. __init__(handle, rosetta.core.scoring.constraints.PeriodicBoundFunc) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.core.scoring.constraints.PeriodicBoundFunc, : rosetta.core.scoring.constraints.PeriodicBoundFunc) -> rosetta.core.scoring.constraints.PeriodicBoundFunc
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.PeriodicBoundFunc) -> rosetta.core.scoring.func.Func
- dfunc(...) from builtins.PyCapsule
- dfunc(self : rosetta.core.scoring.constraints.PeriodicBoundFunc, x : float) -> float
- func(...) from builtins.PyCapsule
- func(self : rosetta.core.scoring.constraints.PeriodicBoundFunc, x : float) -> float
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.PeriodicBoundFunc, rhs : rosetta.core.scoring.func.Func) -> bool
Methods inherited from BoundFunc:
- lb(...) from builtins.PyCapsule
- lb(rosetta.core.scoring.constraints.BoundFunc) -> float
- rswitch(...) from builtins.PyCapsule
- rswitch(rosetta.core.scoring.constraints.BoundFunc) -> float
- sd(...) from builtins.PyCapsule
- sd(rosetta.core.scoring.constraints.BoundFunc) -> float
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.BoundFunc) -> str
- ub(...) from builtins.PyCapsule
- ub(rosetta.core.scoring.constraints.BoundFunc) -> float
Methods inherited from rosetta.core.scoring.func.Func:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.func.Func, other : rosetta.core.scoring.func.Func) -> bool
inequality operator -- simply the negation of the (virtual) equality operator
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.func.Func) -> str
- estimate_dfunc(...) from builtins.PyCapsule
- estimate_dfunc(*args, **kwargs)
Overloaded function.
1. estimate_dfunc(self : 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).
2. estimate_dfunc(self : 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).
|
class ResidueConstraints(builtins.object) |
| |
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
silly helper class, a wrapper for std::map so we can hold in owning_ptr
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
|
| |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(rosetta.core.scoring.constraints.ResidueConstraints) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.core.scoring.constraints.ResidueConstraints, : rosetta.core.scoring.constraints.ResidueConstraints) -> rosetta.core.scoring.constraints.ResidueConstraints
- begin(...) from builtins.PyCapsule
- begin(rosetta.core.scoring.constraints.ResidueConstraints) -> std::_Rb_tree_const_iterator<std::pair<unsigned long const, std::shared_ptr<core::scoring::constraints::Constraints> > >
- clear(...) from builtins.PyCapsule
- clear(rosetta.core.scoring.constraints.ResidueConstraints) -> NoneType
- end(...) from builtins.PyCapsule
- end(rosetta.core.scoring.constraints.ResidueConstraints) -> std::_Rb_tree_const_iterator<std::pair<unsigned long const, std::shared_ptr<core::scoring::constraints::Constraints> > >
- erase(...) from builtins.PyCapsule
- erase(self : rosetta.core.scoring.constraints.ResidueConstraints, seqpos : int) -> NoneType
- find(...) from builtins.PyCapsule
- find(self : rosetta.core.scoring.constraints.ResidueConstraints, seqpos : int) -> std::_Rb_tree_const_iterator<std::pair<unsigned long const, std::shared_ptr<core::scoring::constraints::Constraints> > >
- has(...) from builtins.PyCapsule
- has(self : rosetta.core.scoring.constraints.ResidueConstraints, seqpos : int) -> bool
- insert(...) from builtins.PyCapsule
- insert(self : rosetta.core.scoring.constraints.ResidueConstraints, seqpos : int, cst : rosetta.core.scoring.constraints.Constraints) -> NoneType
- size(...) from builtins.PyCapsule
- size(rosetta.core.scoring.constraints.ResidueConstraints) -> int
|
class ResidueTypeConstraint(Constraint) |
| |
This class favors a particular residue identity at a particular position by reducing its res_type energy.
|
| |
- Method resolution order:
- ResidueTypeConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.ResidueTypeConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(self : handle, pose : rosetta.core.pose.Pose, seqpos : int, native_residue_bonus : float) -> NoneType
3. __init__(self : handle, pose : rosetta.core.pose.Pose, seqpos : int, AAname : str, favor_native_bonus : float) -> NoneType
4. __init__(self : handle, seqpos : int, aa_in : str, name3_in : str, bonus_in : float) -> NoneType
5. __init__(handle, rosetta.core.scoring.constraints.ResidueTypeConstraint) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.ResidueTypeConstraint, : int) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.ResidueTypeConstraint) -> rosetta.core.scoring.constraints.Constraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.ResidueTypeConstraint, atom : rosetta.core.id.AtomID, xyz : rosetta.core.scoring.func.XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.ResidueTypeConstraint) -> int
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.ResidueTypeConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.ResidueTypeConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose) -> rosetta.core.scoring.constraints.Constraint
2. remapped_clone(self : rosetta.core.scoring.constraints.ResidueTypeConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.ResidueTypeConstraint) -> rosetta.utility.vector1_unsigned_long
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.ResidueTypeConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.ResidueTypeConstraint, xyz_func : rosetta.core.scoring.func.XYZ_Func, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.Constraint) -> str
Returns a unique string identified for this constraint. Used in several
places, including the ConstraintIO class.
|
class ResidueTypeLinkingConstraint(Constraint) |
| |
This class favors a particular residue identity at a particular position by reducing its res_type energy.
|
| |
- Method resolution order:
- ResidueTypeLinkingConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
possibility to compare constraint according to data
and not just pointers
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(self : handle, pose : rosetta.core.pose.Pose, seqpos1 : int, seqpos2 : int, bonus : float) -> NoneType
3. __init__(self : handle, pose : rosetta.core.pose.Pose, seqpos1 : int, seqpos2 : int, AA1name : str, AA2name : str, bonus : float) -> NoneType
4. __init__(handle, rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, : int) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint) -> rosetta.core.scoring.constraints.Constraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, atom : rosetta.core.id.AtomID, xyz : rosetta.core.scoring.func.XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint) -> int
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint) -> rosetta.utility.vector1_unsigned_long
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.ResidueTypeLinkingConstraint, xyz_func : rosetta.core.scoring.func.XYZ_Func, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.id.SequenceMapping) -> 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.
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> 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.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.Constraint) -> str
Returns a unique string identified for this constraint. Used in several
places, including the ConstraintIO class.
|
class SequenceProfileConstraint(Constraint) |
| | |
- Method resolution order:
- SequenceProfileConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.SequenceProfileConstraint, : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(handle, rosetta.core.pose.Pose, int) -> NoneType
doc
3. __init__(handle, rosetta.core.pose.Pose, int, core::sequence::SequenceProfile) -> NoneType
doc
4. __init__(self : handle, : rosetta.core.pose.Pose, : int, profile : core::sequence::SequenceProfile, mapping : rosetta.core.id.SequenceMapping) -> NoneType
5. __init__(handle, int) -> NoneType
doc
6. __init__(handle, int, core::sequence::SequenceProfile) -> NoneType
doc
7. __init__(self : handle, : int, profile : core::sequence::SequenceProfile, mapping : rosetta.core.id.SequenceMapping) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.SequenceProfileConstraint, : int) -> rosetta.core.id.AtomID
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.SequenceProfileConstraint) -> rosetta.core.scoring.constraints.Constraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.SequenceProfileConstraint, : rosetta.core.id.AtomID, : rosetta.core.scoring.func.XYZ_Func, : rosetta.numeric.xyzVector_double_t, : rosetta.numeric.xyzVector_double_t, : rosetta.core.scoring.EMapVector) -> NoneType
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.SequenceProfileConstraint) -> int
- profile_mapping(...) from builtins.PyCapsule
- profile_mapping(rosetta.core.scoring.constraints.SequenceProfileConstraint) -> rosetta.core.id.SequenceMapping
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.SequenceProfileConstraint, : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(self : rosetta.core.scoring.constraints.SequenceProfileConstraint, src : rosetta.core.pose.Pose, dest : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.SequenceProfileConstraint) -> rosetta.utility.vector1_unsigned_long
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.SequenceProfileConstraint, : rosetta.core.scoring.constraints.Constraint) -> bool
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.SequenceProfileConstraint, : rosetta.core.scoring.func.XYZ_Func, : rosetta.core.scoring.EMapVector, : rosetta.core.scoring.EMapVector) -> NoneType
- seqpos(...) from builtins.PyCapsule
- seqpos(*args, **kwargs)
Overloaded function.
1. seqpos(rosetta.core.scoring.constraints.SequenceProfileConstraint) -> int
2. seqpos(self : rosetta.core.scoring.constraints.SequenceProfileConstraint, seqpos : int) -> NoneType
- sequence_profile(...) from builtins.PyCapsule
- sequence_profile(rosetta.core.scoring.constraints.SequenceProfileConstraint) -> core::sequence::SequenceProfile
- set_sequence_profile(...) from builtins.PyCapsule
- set_sequence_profile(*args, **kwargs)
Overloaded function.
1. set_sequence_profile(self : rosetta.core.scoring.constraints.SequenceProfileConstraint, profile : core::sequence::SequenceProfile) -> NoneType
2. set_sequence_profile(self : rosetta.core.scoring.constraints.SequenceProfileConstraint, profile : core::sequence::SequenceProfile, mapping : rosetta.core.id.SequenceMapping) -> NoneType
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.SequenceProfileConstraint) -> str
- weight(...) from builtins.PyCapsule
- weight(*args, **kwargs)
Overloaded function.
1. weight(self : rosetta.core.scoring.constraints.SequenceProfileConstraint, w : float) -> NoneType
2. weight(rosetta.core.scoring.constraints.SequenceProfileConstraint) -> float
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class SiteConstraint(AmbiguousConstraint) |
| | |
- Method resolution order:
- SiteConstraint
- AmbiguousConstraint
- MultiConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.SiteConstraint, : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(self : handle, cst_in : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) -> NoneType
3. __init__(handle, rosetta.core.scoring.constraints.SiteConstraint) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.SiteConstraint) -> rosetta.core.scoring.constraints.Constraint
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.SiteConstraint, : rosetta.core.scoring.constraints.Constraint) -> bool
- setup_csts(...) from builtins.PyCapsule
- setup_csts(*args, **kwargs)
Overloaded function.
1. setup_csts(self : rosetta.core.scoring.constraints.SiteConstraint, res : int, name : str, chain : str, pose : rosetta.core.pose.Pose, func : rosetta.core.scoring.func.Func) -> NoneType
Sets up SiteConstaint between the residue of interest and a chain
2. setup_csts(self : rosetta.core.scoring.constraints.SiteConstraint, res : int, name : str, residues : rosetta.utility.vector1_bool, pose : rosetta.core.pose.Pose, func : rosetta.core.scoring.func.Func) -> NoneType
Sets up SiteConstraint between the residue of interest and a subset of residues
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.SiteConstraint) -> str
Methods inherited from AmbiguousConstraint:
- active_constraint(...) from builtins.PyCapsule
- active_constraint(rosetta.core.scoring.constraints.AmbiguousConstraint) -> rosetta.core.scoring.constraints.Constraint
- calculate_total_cst_score(...) from builtins.PyCapsule
- calculate_total_cst_score(self : rosetta.core.scoring.constraints.AmbiguousConstraint, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> float
- empty_clone(...) from builtins.PyCapsule
- empty_clone(rosetta.core.scoring.constraints.AmbiguousConstraint) -> rosetta.core.scoring.constraints.MultiConstraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.AmbiguousConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
compute atom deriv
- init_cst_score_types(...) from builtins.PyCapsule
- init_cst_score_types(rosetta.core.scoring.constraints.AmbiguousConstraint) -> NoneType
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.AmbiguousConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.AmbiguousConstraint, xyz_func : core::scoring::func::XYZ_Func, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
compute score
Methods inherited from MultiConstraint:
- add_individual_constraint(...) from builtins.PyCapsule
- add_individual_constraint(self : rosetta.core.scoring.constraints.MultiConstraint, cst_in : rosetta.core.scoring.constraints.Constraint) -> NoneType
add individual constraint into MultiConstraint
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.MultiConstraint, n : int) -> rosetta.core.id.AtomID
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- member_constraints(...) from builtins.PyCapsule
- member_constraints(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.MultiConstraint) -> int
number of atoms involved in this MultiConstraint container
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose) -> rosetta.core.scoring.constraints.Constraint
2. remapped_clone(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.utility.vector1_unsigned_long
- set_effective_sequence_separation(...) from builtins.PyCapsule
- set_effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, setting : int) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.MultiConstraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- size(...) from builtins.PyCapsule
- size(rosetta.core.scoring.constraints.MultiConstraint) -> int
number of constraints that are held by this %MultiConstraint
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
class SiteConstraintResidues(AmbiguousConstraint) |
| | |
- Method resolution order:
- SiteConstraintResidues
- AmbiguousConstraint
- MultiConstraint
- Constraint
- builtins.object
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.core.scoring.constraints.SiteConstraintResidues, : rosetta.core.scoring.constraints.Constraint) -> bool
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(self : handle, cst_in : rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t) -> NoneType
3. __init__(handle, rosetta.core.scoring.constraints.SiteConstraintResidues) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.constraints.SiteConstraintResidues) -> rosetta.core.scoring.constraints.Constraint
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(self : rosetta.core.scoring.constraints.SiteConstraintResidues, : rosetta.core.scoring.constraints.Constraint) -> bool
- setup_csts(...) from builtins.PyCapsule
- setup_csts(self : rosetta.core.scoring.constraints.SiteConstraintResidues, res1 : int, name : str, res2 : int, res3 : int, pose : rosetta.core.pose.Pose, func : rosetta.core.scoring.func.Func) -> NoneType
- type(...) from builtins.PyCapsule
- type(rosetta.core.scoring.constraints.SiteConstraintResidues) -> str
Methods inherited from AmbiguousConstraint:
- active_constraint(...) from builtins.PyCapsule
- active_constraint(rosetta.core.scoring.constraints.AmbiguousConstraint) -> rosetta.core.scoring.constraints.Constraint
- calculate_total_cst_score(...) from builtins.PyCapsule
- calculate_total_cst_score(self : rosetta.core.scoring.constraints.AmbiguousConstraint, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> float
- empty_clone(...) from builtins.PyCapsule
- empty_clone(rosetta.core.scoring.constraints.AmbiguousConstraint) -> rosetta.core.scoring.constraints.MultiConstraint
- fill_f1_f2(...) from builtins.PyCapsule
- fill_f1_f2(self : rosetta.core.scoring.constraints.AmbiguousConstraint, atom : rosetta.core.id.AtomID, xyz : core::scoring::func::XYZ_Func, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t, weights : rosetta.core.scoring.EMapVector) -> NoneType
compute atom deriv
- init_cst_score_types(...) from builtins.PyCapsule
- init_cst_score_types(rosetta.core.scoring.constraints.AmbiguousConstraint) -> NoneType
- remap_resid(...) from builtins.PyCapsule
- remap_resid(self : rosetta.core.scoring.constraints.AmbiguousConstraint, seqmap : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.constraints.AmbiguousConstraint, xyz_func : core::scoring::func::XYZ_Func, weights : rosetta.core.scoring.EMapVector, emap : rosetta.core.scoring.EMapVector) -> NoneType
compute score
Methods inherited from MultiConstraint:
- add_individual_constraint(...) from builtins.PyCapsule
- add_individual_constraint(self : rosetta.core.scoring.constraints.MultiConstraint, cst_in : rosetta.core.scoring.constraints.Constraint) -> NoneType
add individual constraint into MultiConstraint
- atom(...) from builtins.PyCapsule
- atom(self : rosetta.core.scoring.constraints.MultiConstraint, n : int) -> rosetta.core.id.AtomID
- choose_effective_sequence_separation(...) from builtins.PyCapsule
- choose_effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, sp : rosetta.core.kinematics.ShortestPathInFoldTree, : rosetta.numeric.random.RandomGenerator) -> int
- effective_sequence_separation(...) from builtins.PyCapsule
- effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.kinematics.ShortestPathInFoldTree) -> int
- member_constraints(...) from builtins.PyCapsule
- member_constraints(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.utility.vector1_std_shared_ptr_const_core_scoring_constraints_Constraint_t
- natoms(...) from builtins.PyCapsule
- natoms(rosetta.core.scoring.constraints.MultiConstraint) -> int
number of atoms involved in this MultiConstraint container
- remapped_clone(...) from builtins.PyCapsule
- remapped_clone(*args, **kwargs)
Overloaded function.
1. remapped_clone(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose) -> rosetta.core.scoring.constraints.Constraint
2. remapped_clone(self : rosetta.core.scoring.constraints.MultiConstraint, : rosetta.core.pose.Pose, : rosetta.core.pose.Pose, map : rosetta.core.id.SequenceMapping) -> rosetta.core.scoring.constraints.Constraint
- residues(...) from builtins.PyCapsule
- residues(rosetta.core.scoring.constraints.MultiConstraint) -> rosetta.utility.vector1_unsigned_long
- set_effective_sequence_separation(...) from builtins.PyCapsule
- set_effective_sequence_separation(self : rosetta.core.scoring.constraints.MultiConstraint, setting : int) -> NoneType
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.constraints.MultiConstraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- size(...) from builtins.PyCapsule
- size(rosetta.core.scoring.constraints.MultiConstraint) -> int
number of constraints that are held by this %MultiConstraint
Methods inherited from Constraint:
- __ne__(...) from builtins.PyCapsule
- __ne__(self : rosetta.core.scoring.constraints.Constraint, other : rosetta.core.scoring.constraints.Constraint) -> bool
Inequality operator to test whether two constraints are not functionally
identical.
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.constraints.Constraint) -> str
- dist(...) from builtins.PyCapsule
- dist(*args, **kwargs)
Overloaded function.
1. dist(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> float
return the raw "distance" before that distance is handed to the FUNC object
2. dist(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func) -> float
- get_func(...) from builtins.PyCapsule
- get_func(rosetta.core.scoring.constraints.Constraint) -> core::scoring::func::Func
Returns the func::Func object associated with this Constraint object.
- score_type(...) from builtins.PyCapsule
- score_type(rosetta.core.scoring.constraints.Constraint) -> rosetta.core.scoring.ScoreType
Returns the ScoreType that this Constraint object will use.
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.constraints.Constraint, : core::scoring::func::XYZ_Func, : rosetta.core.scoring.ScoreFunction) -> NoneType
- steal_def(...) from builtins.PyCapsule
- steal_def(self : rosetta.core.scoring.constraints.Constraint, : rosetta.core.pose.Pose) -> NoneType
take coordinates, distances, angles, etc from given pose
- to_string(...) from builtins.PyCapsule
- to_string(rosetta.core.scoring.constraints.Constraint) -> str
Convenience function, returns the results of show() as a string.
Not to be overriden by derived classes.
|
|