| | |
- rosetta.core.scoring.Energies(builtins.object)
-
- SymmetricEnergies
- rosetta.core.scoring.ScoreFunction(builtins.object)
-
- SymmetricScoreFunction
class SymmetricEnergies(rosetta.core.scoring.Energies) |
| | |
- Method resolution order:
- SymmetricEnergies
- rosetta.core.scoring.Energies
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(self : handle, src : rosetta.core.scoring.Energies) -> NoneType
3. __init__(self : handle, src : rosetta.core.scoring.Energies) -> NoneType
4. __init__(handle, rosetta.core.scoring.symmetry.SymmetricEnergies) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(*args, **kwargs)
Overloaded function.
1. assign(self : rosetta.core.scoring.symmetry.SymmetricEnergies, rhs : rosetta.core.scoring.Energies) -> rosetta.core.scoring.Energies
2. assign(self : rosetta.core.scoring.symmetry.SymmetricEnergies, : rosetta.core.scoring.symmetry.SymmetricEnergies) -> rosetta.core.scoring.symmetry.SymmetricEnergies
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.symmetry.SymmetricEnergies) -> rosetta.core.scoring.Energies
- derivative_graph(...) from builtins.PyCapsule
- derivative_graph(*args, **kwargs)
Overloaded function.
1. derivative_graph(rosetta.core.scoring.symmetry.SymmetricEnergies) -> rosetta.core.scoring.MinimizationGraph
2. derivative_graph(rosetta.core.scoring.symmetry.SymmetricEnergies) -> rosetta.core.scoring.MinimizationGraph
- same_type_as_me(...) from builtins.PyCapsule
- same_type_as_me(*args, **kwargs)
Overloaded function.
1. same_type_as_me(self : rosetta.core.scoring.symmetry.SymmetricEnergies, other : rosetta.core.scoring.Energies) -> bool
determine whether my type is the same as another Conformation's
2. same_type_as_me(self : rosetta.core.scoring.symmetry.SymmetricEnergies, other : rosetta.core.scoring.Energies, recurse : bool) -> bool
determine whether my type is the same as another Conformation's
- set_derivative_graph(...) from builtins.PyCapsule
- set_derivative_graph(self : rosetta.core.scoring.symmetry.SymmetricEnergies, dg : rosetta.core.scoring.MinimizationGraph) -> NoneType
Methods inherited from rosetta.core.scoring.Energies:
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.Energies) -> str
- clear(...) from builtins.PyCapsule
- clear(rosetta.core.scoring.Energies) -> NoneType
kill everything (that nobody forgot about)
- clear_energies(...) from builtins.PyCapsule
- clear_energies(rosetta.core.scoring.Energies) -> NoneType
for debugging -- forget all stored energies, does not change size
- context_graph(...) from builtins.PyCapsule
- context_graph(*args, **kwargs)
Overloaded function.
1. context_graph(self : rosetta.core.scoring.Energies, type : rosetta.core.scoring.ContextGraphType) -> core::scoring::ContextGraph
2. context_graph(self : rosetta.core.scoring.Energies, type : rosetta.core.scoring.ContextGraphType) -> core::scoring::ContextGraph
- data(...) from builtins.PyCapsule
- data(*args, **kwargs)
Overloaded function.
1. data(rosetta.core.scoring.Energies) -> rosetta.basic.datacache.BasicDataCache
BasicDataCache indexed by enum in core/scoring/EnergiesCacheableDataType.hh
2. data(rosetta.core.scoring.Energies) -> rosetta.basic.datacache.BasicDataCache
BasicDataCache indexed by enum in core/scoring/EnergiesCacheableDataType.hh
- discard_conformation_domain_map(...) from builtins.PyCapsule
- discard_conformation_domain_map(rosetta.core.scoring.Energies) -> bool
instructs Pose whether the domain map info in the Conformation object should be discarded
- domain_map(...) from builtins.PyCapsule
- domain_map(*args, **kwargs)
Overloaded function.
1. domain_map(self : rosetta.core.scoring.Energies, pos : int) -> int
Return the color assigned to a particular residue (index = pos) as held in the
domain map describing how this residue has moved with respect to the other residues in the
pose.
CAUTION new behavior: domain_map may not return 0 for residues that have undergone internal
degree of freedom changes since the last scoring. Ask the res_moved() method for that information
2. domain_map(rosetta.core.scoring.Energies) -> ObjexxFCL::FArray1D<int>
Read access for the domain map.
- energies_updated(...) from builtins.PyCapsule
- energies_updated(rosetta.core.scoring.Energies) -> bool
Returns true if the score is up-to-date
example(s):
pose.energies().energies_updated()
See also:
Energies
Energies.residue_total_energy
Energies.residue_total_energies
Pose
ScoreFunction
ScoreFunction.show
create_score_function
- energy_graph(...) from builtins.PyCapsule
- energy_graph(*args, **kwargs)
Overloaded function.
1. energy_graph(rosetta.core.scoring.Energies) -> core::scoring::EnergyGraph
Read access to the EnergyGraph.
2. energy_graph(rosetta.core.scoring.Energies) -> core::scoring::EnergyGraph
Write access to the EnergyGraph.
- finalized_energies(...) from builtins.PyCapsule
- finalized_energies(*args, **kwargs)
Overloaded function.
1. finalized_energies(rosetta.core.scoring.Energies) -> rosetta.core.scoring.EMapVector
Read access to the components of the "finalized" energies;
These will include any score component calculated in the finalize
phase of score function evaluation. These energies are copied
between Energies objects, and are not evaluated during the component-
energy update.
2. finalized_energies(rosetta.core.scoring.Energies) -> rosetta.core.scoring.EMapVector
Write access to the components of the "finalized" energies.
This access is intended only for the ScoreFunction.
- get_scorefxn_info(...) from builtins.PyCapsule
- get_scorefxn_info(rosetta.core.scoring.Energies) -> core::scoring::ScoreFunctionInfo
get scorefxn info
- long_range_container(...) from builtins.PyCapsule
- long_range_container(self : rosetta.core.scoring.Energies, : rosetta.core.scoring.methods.LongRangeEnergyType) -> core::scoring::LREnergyContainer
- minimization_graph(...) from builtins.PyCapsule
- minimization_graph(*args, **kwargs)
Overloaded function.
1. minimization_graph(rosetta.core.scoring.Energies) -> core::scoring::MinimizationGraph
2. minimization_graph(rosetta.core.scoring.Energies) -> core::scoring::MinimizationGraph
- nblist(...) from builtins.PyCapsule
- nblist(self : rosetta.core.scoring.Energies, type : rosetta.core.scoring.EnergiesCacheableDataType.Enum) -> core::scoring::NeighborList
- nonconst_long_range_container(...) from builtins.PyCapsule
- nonconst_long_range_container(self : rosetta.core.scoring.Energies, : rosetta.core.scoring.methods.LongRangeEnergyType) -> core::scoring::LREnergyContainer
- onebody_energies(...) from builtins.PyCapsule
- onebody_energies(*args, **kwargs)
Overloaded function.
1. onebody_energies(self : rosetta.core.scoring.Energies, seqpos : int) -> rosetta.core.scoring.EMapVector
Read access to the components of the one-body energies.
2. onebody_energies(self : rosetta.core.scoring.Energies, seqpos : int) -> rosetta.core.scoring.EMapVector
Write access to the components of the one-body energies.
This access is intended only for the ScoreFunction.
- require_context_graph(...) from builtins.PyCapsule
- require_context_graph(self : rosetta.core.scoring.Energies, : rosetta.core.scoring.ContextGraphType) -> NoneType
Allows non-scorefunction components of Rosetta to impose requirements on
the context graphs that this object maintains.
- res_moved(...) from builtins.PyCapsule
- res_moved(self : rosetta.core.scoring.Energies, seqpos : int) -> bool
check if rsd has changed internal conformation, necessitating, recomputation of 1d energies like dun,intra,prob,etc
- reset_nblist(...) from builtins.PyCapsule
- reset_nblist(rosetta.core.scoring.Energies) -> NoneType
- reset_res_moved(...) from builtins.PyCapsule
- reset_res_moved(self : rosetta.core.scoring.Energies, seqpos : int) -> NoneType
- residue_neighbors_updated(...) from builtins.PyCapsule
- residue_neighbors_updated(rosetta.core.scoring.Energies) -> bool
- residue_total_energies(...) from builtins.PyCapsule
- residue_total_energies(self : rosetta.core.scoring.Energies, seqpos : int) -> rosetta.core.scoring.EMapVector
Returns the unweighted total_energies EnergyMap for
Residue <seqpos>
: only evaluated when requested (lazy!), inaccessible during
minimization, EnergyMap is an EMapVector
example(s):
r3 = pose.energies().residue_total_energies(3)
r3[fa_sol]
See also:
Energies
Energies.residue_total_energy
Pose
ScoreFunction
ScoreFunction.show
create_score_function
EMapVector
- residue_total_energy(...) from builtins.PyCapsule
- residue_total_energy(self : rosetta.core.scoring.Energies, seqpos : int) -> float
Returns the weighted total energy of residue <seqpos>
example(s):
pose.energies().residue_total_energy(3)
See also:
Energies
Energies.residue_total_energies
Pose
ScoreFunction
ScoreFunction.show
create_score_function
- scoring(...) from builtins.PyCapsule
- scoring(rosetta.core.scoring.Energies) -> bool
are we in the midst of a scoring calculation?
- scoring_begin(...) from builtins.PyCapsule
- scoring_begin(self : rosetta.core.scoring.Energies, sfxn : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
Notification of the start of a scoring calculation.
- scoring_end(...) from builtins.PyCapsule
- scoring_end(self : rosetta.core.scoring.Energies, scorefxn : rosetta.core.scoring.ScoreFunction) -> NoneType
signal from the scorefxn that scoring is over
- set_long_range_container(...) from builtins.PyCapsule
- set_long_range_container(self : rosetta.core.scoring.Energies, : rosetta.core.scoring.methods.LongRangeEnergyType, : core::scoring::LREnergyContainer) -> NoneType
- set_minimization_graph(...) from builtins.PyCapsule
- set_minimization_graph(self : rosetta.core.scoring.Energies, : core::scoring::MinimizationGraph) -> NoneType
- set_nblist(...) from builtins.PyCapsule
- set_nblist(self : rosetta.core.scoring.Energies, type : rosetta.core.scoring.EnergiesCacheableDataType.Enum, nblist_in : core::scoring::NeighborList) -> NoneType
- set_owner(...) from builtins.PyCapsule
- set_owner(self : rosetta.core.scoring.Energies, owner : rosetta.core.pose.Pose) -> NoneType
Pose must claim its Energies object; this should happen once,
at the time the Pose is allocated. Future copying of the Energies object
will not change ownership. The purpose of ownership is to allow lazy context-graph
creation. When context graphs are requested that have not been created, they
must be created and their edges must be updated to represent the current conformation
of the pose.
- set_use_nblist(...) from builtins.PyCapsule
- set_use_nblist(self : rosetta.core.scoring.Energies, pose : rosetta.core.pose.Pose, domain_map_in : ObjexxFCL::FArray1D<int>, use_nblist_auto_update : bool) -> NoneType
- show(...) from builtins.PyCapsule
- show(*args, **kwargs)
Overloaded function.
1. show(rosetta.core.scoring.Energies) -> NoneType
2. show(self : rosetta.core.scoring.Energies, res : int) -> NoneType
Shows the energy information of residue <seqpos>
: wrapper function of energies.show(Size) for Pyrosetta
example(s):
pose.energies().show(3)
See also:
Energies
Energies.residue_total_energies
Energies.residue_total_energy
Pose
ScoreFunction
ScoreFunction.show
create_score_function
- size(...) from builtins.PyCapsule
- size(rosetta.core.scoring.Energies) -> int
Returns the number of held residue energies
example(s):
r3 = pose.energies().residue_total_energies(3)
r3[fa_sol]
See also:
Energies
Energies.residue_total_energies
Energies.residue_total_energy
Pose
ScoreFunction
ScoreFunction.show
create_score_function
- structure_has_moved(...) from builtins.PyCapsule
- structure_has_moved(self : rosetta.core.scoring.Energies, nres : int) -> NoneType
called (eg by pose) to notify us of a change to the structure
Triggers clearing of the total energies and the twobody rsd energies
PHIL -- should also mark the neighbor links as invalid somehow...
Called by pose when someone tries to access us, if the Conformation
indicates that the structure has moved since the last score evaluation
const b/c called inside const access methods
- tenA_neighbor_graph(...) from builtins.PyCapsule
- tenA_neighbor_graph(*args, **kwargs)
Overloaded function.
1. tenA_neighbor_graph(rosetta.core.scoring.Energies) -> core::scoring::TenANeighborGraph
get the graph encoding # neighbors within 10 Angstroms
If the graph has not been requested up until this point, then it will
be instantiated and filled. If the pose has changed size since the last
score function evaluation (or if the pose has never been scored) this
function will exit.
2. tenA_neighbor_graph(rosetta.core.scoring.Energies) -> core::scoring::TenANeighborGraph
Write access to the graph encoding # neighbors within 10 Angstroms
If the graph has not been requested up until this point, then it will
be instantiated and filled. If the pose has changed size since the last
score function evaluation (or if the pose has never been scored) this
function will exit.
- total_energies(...) from builtins.PyCapsule
- total_energies(*args, **kwargs)
Overloaded function.
1. total_energies(rosetta.core.scoring.Energies) -> rosetta.core.scoring.EMapVector
Returns the total_energies EnergyMap after first computing the
component energies if they are not up-to-date
2. total_energies(rosetta.core.scoring.Energies) -> rosetta.core.scoring.EMapVector
Returns a non-const reference to the total_energies EnergyMap
so that external sources may append additional information to the Energies
object. This is primarily useful for outputting score data with structures
when those terms are not part of the energy function.
This function will update the component energies if they are not up-to-date.
- total_energy(...) from builtins.PyCapsule
- total_energy(*args, **kwargs)
Overloaded function.
1. total_energy(rosetta.core.scoring.Energies) -> float
Returns the total score
example(s):
pose.energies().total_energy()
See also:
Energies
Energies.residue_total_energy
Energies.residue_total_energies
Pose
ScoreFunction
ScoreFunction.show
create_score_function
2. total_energy(rosetta.core.scoring.Energies) -> float
- twelveA_neighbor_graph(...) from builtins.PyCapsule
- twelveA_neighbor_graph(*args, **kwargs)
Overloaded function.
1. twelveA_neighbor_graph(rosetta.core.scoring.Energies) -> core::scoring::TwelveANeighborGraph
get the graph encoding # neighbors within 12 Angstroms
2. twelveA_neighbor_graph(rosetta.core.scoring.Energies) -> core::scoring::TwelveANeighborGraph
- update_residue_neighbors(...) from builtins.PyCapsule
- update_residue_neighbors(self : rosetta.core.scoring.Energies, domain_map_in : ObjexxFCL::FArray1D<int>, pose : rosetta.core.pose.Pose) -> NoneType
update the residue neighbors
- use_nblist(...) from builtins.PyCapsule
- use_nblist(rosetta.core.scoring.Energies) -> bool
- use_nblist_auto_update(...) from builtins.PyCapsule
- use_nblist_auto_update(rosetta.core.scoring.Energies) -> bool
- use_nblist_of_type(...) from builtins.PyCapsule
- use_nblist_of_type(self : rosetta.core.scoring.Energies, type : rosetta.core.scoring.EnergiesCacheableDataType.Enum) -> bool
- weights(...) from builtins.PyCapsule
- weights(*args, **kwargs)
Overloaded function.
1. weights(rosetta.core.scoring.Energies) -> rosetta.core.scoring.EMapVector
Returns an EnergyMap of the ScoreFunction weights from the last
scoring
example(s):
we = pose.energies().weights()
we[fa_atr]
See also:
Energies
Energies.residue_total_energies
Energies.residue_total_energy
Pose
ScoreFunction
ScoreFunction.show
create_score_function
EMapVector
2. weights(self : rosetta.core.scoring.Energies, new_weights : rosetta.core.scoring.EMapVector) -> NoneType
Setter for the weights in this Energies object.
|
class SymmetricScoreFunction(rosetta.core.scoring.ScoreFunction) |
| | |
- Method resolution order:
- SymmetricScoreFunction
- rosetta.core.scoring.ScoreFunction
- builtins.object
Methods defined here:
- __call__(...) from builtins.PyCapsule
- __call__(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, pose : rosetta.core.pose.Pose) -> float
//////////////////////////////////////////////////////////////////////////
- __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(*args, **kwargs)
Overloaded function.
1. assign(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, src : rosetta.core.scoring.ScoreFunction) -> NoneType
NOT FOR GENERAL USE
Copy the information about src into the current score function.
There are deep interactions with subclasses,
(the subclass information doesn't necessarily get copied)
so this is primarily for advanced scorefunction manipulation.
Normal usage should just use clone() and replace the OP.
2. assign(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, src : rosetta.core.scoring.symmetry.SymmetricScoreFunction) -> NoneType
NOT FOR GENERAL USE
- clone(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.symmetry.SymmetricScoreFunction) -> rosetta.core.scoring.ScoreFunction
- correct_arrays_for_symmetry(...) from builtins.PyCapsule
- correct_arrays_for_symmetry(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
- correct_finalize_score(...) from builtins.PyCapsule
- correct_finalize_score(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
- eval_dof_derivative(...) from builtins.PyCapsule
- eval_dof_derivative(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, dof_id : rosetta.core.id.DOF_ID, torsion_id : rosetta.core.id.TorsionID, pose : rosetta.core.pose.Pose) -> float
- eval_long_range_twobody_energies(...) from builtins.PyCapsule
- eval_long_range_twobody_energies(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
- eval_npd_atom_derivative(...) from builtins.PyCapsule
- eval_npd_atom_derivative(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, atom_id : rosetta.core.id.AtomID, pose : rosetta.core.pose.Pose, domain_map : ObjexxFCL::FArray1D<int>, F1 : rosetta.numeric.xyzVector_double_t, F2 : rosetta.numeric.xyzVector_double_t) -> NoneType
- eval_onebody_energies(...) from builtins.PyCapsule
- eval_onebody_energies(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
- eval_twobody_neighbor_energies(...) from builtins.PyCapsule
- eval_twobody_neighbor_energies(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
- intersubunit_hbond_energy(...) from builtins.PyCapsule
- intersubunit_hbond_energy(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, pose : rosetta.core.pose.Pose, intersubunit_energy : rosetta.core.scoring.EMapVector) -> NoneType
- set_symmetric_cenlist(...) from builtins.PyCapsule
- set_symmetric_cenlist(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
- set_symmetric_residue_neighbors_hbonds(...) from builtins.PyCapsule
- set_symmetric_residue_neighbors_hbonds(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
- setup_for_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
- setup_for_minimizing(...) from builtins.PyCapsule
- setup_for_minimizing(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, pose : rosetta.core.pose.Pose, min_map : rosetta.core.kinematics.MinimizerMapBase) -> NoneType
Initialize a MinimizationGraph and cache it in the pose's Energies object
for use during minimization -- only add edges to the asymmetric unit and within it
are added to the MinimizationGraph.
- symmetrical_allow_hbonds(...) from builtins.PyCapsule
- symmetrical_allow_hbonds(self : rosetta.core.scoring.symmetry.SymmetricScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
Methods inherited from rosetta.core.scoring.ScoreFunction:
- __getitem__(...) from builtins.PyCapsule
- __getitem__(self : rosetta.core.scoring.ScoreFunction, t : rosetta.core.scoring.ScoreType) -> float
Returns the weight of the ScoreType <t>
example(s):
scorefxn[fa_sol]
See also:
ScoreFunction
ScoreFunction.get_weight
ScoreFunction.set_weight
ScoreFunction.weights
ScoreType
create_score_function
name_from_score_type
score_type_from_name
- __str__(...) from builtins.PyCapsule
- __str__(rosetta.core.scoring.ScoreFunction) -> str
- add_extra_method(...) from builtins.PyCapsule
- add_extra_method(*args, **kwargs)
Overloaded function.
1. add_extra_method(self : rosetta.core.scoring.ScoreFunction, new_type : rosetta.core.scoring.ScoreType, new_weight : float, new_method : core::scoring::methods::EnergyMethod) -> NoneType
Adds a scoring method that is not necessarily included in
the core library
2. add_extra_method(self : rosetta.core.scoring.ScoreFunction, new_weights : rosetta.std.map_core_scoring_ScoreType_double, new_method : core::scoring::methods::EnergyMethod) -> NoneType
Adds a scoring method that is not necessarily included in
the core library
- add_weights_from_file(...) from builtins.PyCapsule
- add_weights_from_file(self : rosetta.core.scoring.ScoreFunction, filename : str) -> NoneType
Initializes this ScoreFunction from the given <filename>
- all_energies_begin(...) from builtins.PyCapsule
- all_energies_begin(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::EnergyMethod const> const*, std::vector<std::shared_ptr<core::scoring::methods::EnergyMethod const>, std::allocator<std::shared_ptr<core::scoring::methods::EnergyMethod const> > > >
- all_energies_end(...) from builtins.PyCapsule
- all_energies_end(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::EnergyMethod const> const*, std::vector<std::shared_ptr<core::scoring::methods::EnergyMethod const>, std::allocator<std::shared_ptr<core::scoring::methods::EnergyMethod const> > > >
- all_methods(...) from builtins.PyCapsule
- all_methods(rosetta.core.scoring.ScoreFunction) -> rosetta.utility.vector1_std_shared_ptr_const_core_scoring_methods_EnergyMethod_t
- any_lr_residue_pair_energy(...) from builtins.PyCapsule
- any_lr_residue_pair_energy(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, res1 : int, res2 : int) -> bool
- apply_patch_from_file(...) from builtins.PyCapsule
- apply_patch_from_file(self : rosetta.core.scoring.ScoreFunction, filename : str) -> NoneType
Applies a patch from the given <filename>
- are_they_neighbors(...) from builtins.PyCapsule
- are_they_neighbors(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, pos1 : int, pos2 : int) -> bool
Returns true if the <pose> positions <pos1> and <pos2>
are neighbors
- bump_check_backbone(...) from builtins.PyCapsule
- bump_check_backbone(self : rosetta.core.scoring.ScoreFunction, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
Scores the sidechain from <pose> Residue <rsd1> against the
backbone of Residue <rsd2>
- bump_check_full(...) from builtins.PyCapsule
- bump_check_full(self : rosetta.core.scoring.ScoreFunction, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
- cd_1b_types(...) from builtins.PyCapsule
- cd_1b_types(rosetta.core.scoring.ScoreFunction) -> rosetta.utility.vector1_core_scoring_ScoreType
convenience access to all cd 1b score types
- cd_2b_begin(...) from builtins.PyCapsule
- cd_2b_begin(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextDependentTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextDependentTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextDependentTwoBodyEnergy> > > >
- cd_2b_end(...) from builtins.PyCapsule
- cd_2b_end(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextDependentTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextDependentTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextDependentTwoBodyEnergy> > > >
- cd_2b_intrares_begin(...) from builtins.PyCapsule
- cd_2b_intrares_begin(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> > > >
- cd_2b_intrares_end(...) from builtins.PyCapsule
- cd_2b_intrares_end(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> > > >
- cd_2b_types(...) from builtins.PyCapsule
- cd_2b_types(rosetta.core.scoring.ScoreFunction) -> rosetta.utility.vector1_core_scoring_ScoreType
convenience access to all cd 2b score types
- cd_lr_2b_methods_begin(...) from builtins.PyCapsule
- cd_lr_2b_methods_begin(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextDependentLRTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextDependentLRTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextDependentLRTwoBodyEnergy> > > >
- cd_lr_2b_methods_end(...) from builtins.PyCapsule
- cd_lr_2b_methods_end(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextDependentLRTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextDependentLRTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextDependentLRTwoBodyEnergy> > > >
- cd_lr_2b_types(...) from builtins.PyCapsule
- cd_lr_2b_types(rosetta.core.scoring.ScoreFunction) -> rosetta.utility.vector1_core_scoring_ScoreType
- check_methods_in_right_order(...) from builtins.PyCapsule
- check_methods_in_right_order(self : rosetta.core.scoring.ScoreFunction, score_type_in_first_method : rosetta.core.scoring.ScoreType, score_type_in_second_method : rosetta.core.scoring.ScoreType) -> bool
check order of methods
- ci_1b_types(...) from builtins.PyCapsule
- ci_1b_types(rosetta.core.scoring.ScoreFunction) -> rosetta.utility.vector1_core_scoring_ScoreType
convenience access to all ci 1b score types
- ci_2b_begin(...) from builtins.PyCapsule
- ci_2b_begin(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextIndependentTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextIndependentTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextIndependentTwoBodyEnergy> > > >
- ci_2b_end(...) from builtins.PyCapsule
- ci_2b_end(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextIndependentTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextIndependentTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextIndependentTwoBodyEnergy> > > >
- ci_2b_intrares_begin(...) from builtins.PyCapsule
- ci_2b_intrares_begin(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> > > >
- ci_2b_intrares_end(...) from builtins.PyCapsule
- ci_2b_intrares_end(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> > > >
- ci_2b_types(...) from builtins.PyCapsule
- ci_2b_types(rosetta.core.scoring.ScoreFunction) -> rosetta.utility.vector1_core_scoring_ScoreType
convenience access to all ci 2b score types
- ci_lr_2b_methods_begin(...) from builtins.PyCapsule
- ci_lr_2b_methods_begin(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextIndependentLRTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextIndependentLRTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextIndependentLRTwoBodyEnergy> > > >
- ci_lr_2b_methods_end(...) from builtins.PyCapsule
- ci_lr_2b_methods_end(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextIndependentLRTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextIndependentLRTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextIndependentLRTwoBodyEnergy> > > >
- ci_lr_2b_types(...) from builtins.PyCapsule
- ci_lr_2b_types(rosetta.core.scoring.ScoreFunction) -> rosetta.utility.vector1_core_scoring_ScoreType
- clone_as_base_class(...) from builtins.PyCapsule
- clone_as_base_class(rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.ScoreFunction
If you *want* to discard subclass information, the following function is availible
- energy_method_options(...) from builtins.PyCapsule
- energy_method_options(rosetta.core.scoring.ScoreFunction) -> core::scoring::methods::EnergyMethodOptions
Returns the EnergyMethodOptions object contained in this
ScoreFunction (const access)
- eval_cd_1b(...) from builtins.PyCapsule
- eval_cd_1b(self : rosetta.core.scoring.ScoreFunction, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
Accumulates the unweighted one body energies of all context
dependent one body energies for <pose> Residue <rsd> into
EnergyMap <emap>
: EnergyMap is an EMapVector
- eval_cd_2b(...) from builtins.PyCapsule
- eval_cd_2b(self : rosetta.core.scoring.ScoreFunction, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
Accumulate the unweighted short range context dependent two body
interaction energies of <pose> between Residue <rsd1> and Residue
<rsd2> into EnergyMap <emap>
: EnergyMap is an EMapVector
- eval_cd_2b_bb_bb(...) from builtins.PyCapsule
- eval_cd_2b_bb_bb(self : rosetta.core.scoring.ScoreFunction, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
Accumulates the unweighted short ranged context dependent two body
interaction energies of <pose> between the backbones of Residue
<rsd1> and <rsd2> into EnergyMap <emap>
: EnergyMap is an EMapVector
- eval_cd_2b_bb_sc(...) from builtins.PyCapsule
- eval_cd_2b_bb_sc(self : rosetta.core.scoring.ScoreFunction, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
Accumulates the unweighted short ranged context dependent two body
interaction energies of <pose> between the backbone of Residue <rsd1>
and the sidechain of Residue <rsd2> into EnergyMap <emap>
: EnergyMap is an EMapVector
- eval_cd_2b_sc_sc(...) from builtins.PyCapsule
- eval_cd_2b_sc_sc(self : rosetta.core.scoring.ScoreFunction, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
Accumulates the unweighted short ranged context dependent two body
interaction energies of <pose> between the sidechains of Residue
<rsd1> and Residue <rsd2> into EnergyMap <emap>
: EnergyMap is an EMapVector
- eval_cd_intrares_energy(...) from builtins.PyCapsule
- eval_cd_intrares_energy(self : rosetta.core.scoring.ScoreFunction, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
Accumulates the unweighted intra-residue one body energies for all
context dependent two body terms that define intra-residue energies of
<pose> Residue <rsd> into EnergyMap <emap>
: EnergyMap is an EMapVector
- eval_ci_1b(...) from builtins.PyCapsule
- eval_ci_1b(self : rosetta.core.scoring.ScoreFunction, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
- eval_ci_2b(...) from builtins.PyCapsule
- eval_ci_2b(self : rosetta.core.scoring.ScoreFunction, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
Accumulates the unweighted context independent two body
interaction energies of <pose> between Residue <rsd1> and Residue
<rsd2> into EnergyMap <emap>
: EnergyMap is an EMapVector
- eval_ci_2b_bb_bb(...) from builtins.PyCapsule
- eval_ci_2b_bb_bb(self : rosetta.core.scoring.ScoreFunction, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
Accumulates the unweighted context independent two body
interaction energies of <pose> between the backbones of Residue
<rsd1> and Residue <rsd2> into EnergyMap <emap>
: EnergyMap is an EMapVector
- eval_ci_2b_bb_sc(...) from builtins.PyCapsule
- eval_ci_2b_bb_sc(self : rosetta.core.scoring.ScoreFunction, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
Accumulates the unweighted short range context independent two
body interaction energies of <pose> between the backbone of Residue
<rsd1> and the sidechain of Residue <rsd2> into EnergyMap <emap>
: EnergyMap is an EMapVector
- eval_ci_2b_sc_sc(...) from builtins.PyCapsule
- eval_ci_2b_sc_sc(self : rosetta.core.scoring.ScoreFunction, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
Accumulates the unweighted short range context dependent two body
interaction energies of <pose> between the sidechains of Residue <rsd1>
and Residue <rsd2> into Energymap <emap>
: EnergyMap is an EMapVector
- eval_ci_intrares_energy(...) from builtins.PyCapsule
- eval_ci_intrares_energy(self : rosetta.core.scoring.ScoreFunction, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
Accumulates the unweighted intra-residue one body energies for all
context independent two body terms that define intra-residue energies of
<pose> Residue <rsd> into EnergyMap <emap>
: EnergyMap is an EMapVector
- eval_intrares_energy(...) from builtins.PyCapsule
- eval_intrares_energy(self : rosetta.core.scoring.ScoreFunction, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
Accumulates for rsd the unweighted intra-residue one body energies
for all context dependent and context independent two body terms that
define intra-residue energies
: EnergyMap is an EMapVector
- evaluate_rotamer_background_energies(...) from builtins.PyCapsule
- evaluate_rotamer_background_energies(self : rosetta.core.scoring.ScoreFunction, set1 : rosetta.core.conformation.RotamerSetBase, residue2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, energy_vector : rosetta.utility.vector1_float) -> NoneType
- evaluate_rotamer_intrares_energies(...) from builtins.PyCapsule
- evaluate_rotamer_intrares_energies(self : rosetta.core.scoring.ScoreFunction, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, energies : rosetta.utility.vector1_float) -> NoneType
- evaluate_rotamer_intrares_energy_maps(...) from builtins.PyCapsule
- evaluate_rotamer_intrares_energy_maps(self : rosetta.core.scoring.ScoreFunction, set : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, emaps : rosetta.utility.vector1_core_scoring_EMapVector) -> NoneType
- evaluate_rotamer_pair_energies(...) from builtins.PyCapsule
- evaluate_rotamer_pair_energies(self : rosetta.core.scoring.ScoreFunction, set1 : rosetta.core.conformation.RotamerSetBase, set2 : rosetta.core.conformation.RotamerSetBase, pose : rosetta.core.pose.Pose, energy_table : ObjexxFCL::FArray2D<float>) -> NoneType
- finalize_after_derivatives(...) from builtins.PyCapsule
- finalize_after_derivatives(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
- get_name(...) from builtins.PyCapsule
- get_name(rosetta.core.scoring.ScoreFunction) -> str
- get_nonzero_weighted_scoretypes(...) from builtins.PyCapsule
- get_nonzero_weighted_scoretypes(rosetta.core.scoring.ScoreFunction) -> rosetta.utility.vector1_core_scoring_ScoreType
Returns a list of the ScoreTypes which are non-zero with
their current weights
example(s):
scorefxn.get_nonzero_weighted_scoretypes()
See also:
ScoreFunction
ScoreFunction.get_weight
ScoreFunction.set_weight
ScoreFunction.weights
ScoreType
create_score_function
name_from_score_type
score_type_from_name
- get_self_ptr(...) from builtins.PyCapsule
- get_self_ptr(*args, **kwargs)
Overloaded function.
1. get_self_ptr(rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.ScoreFunction
self pointers
2. get_self_ptr(rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.ScoreFunction
- get_sub_score(...) from builtins.PyCapsule
- get_sub_score(*args, **kwargs)
Overloaded function.
1. get_sub_score(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, residue_mask : rosetta.utility.vector1_bool) -> float
Compute the score for subset of residues
2. get_sub_score(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, residue_mask : rosetta.utility.vector1_bool, emap : rosetta.core.scoring.EMapVector) -> NoneType
Compute the score for subset of residues
3. get_sub_score(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, residue_mask : rosetta.utility.vector1_bool) -> float
Compute the score for subset of residues
4. get_sub_score(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, residue_mask : rosetta.utility.vector1_bool, emap : rosetta.core.scoring.EMapVector) -> NoneType
Compute the score for subset of residues
- get_sub_score_exclude_res(...) from builtins.PyCapsule
- get_sub_score_exclude_res(*args, **kwargs)
Overloaded function.
1. get_sub_score_exclude_res(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, exclude_list : rosetta.utility.vector1_unsigned_long) -> float
Compute the score for subset of residues
2. get_sub_score_exclude_res(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, exclude_list : rosetta.utility.vector1_unsigned_long, emap : rosetta.core.scoring.EMapVector) -> NoneType
Compute the score for subset of residues
3. get_sub_score_exclude_res(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, exclude_list : rosetta.utility.vector1_unsigned_long) -> float
Compute the score for subset of residues
4. get_sub_score_exclude_res(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, exclude_list : rosetta.utility.vector1_unsigned_long, emap : rosetta.core.scoring.EMapVector) -> NoneType
Compute the score for subset of residues
- get_weight(...) from builtins.PyCapsule
- get_weight(self : rosetta.core.scoring.ScoreFunction, t : rosetta.core.scoring.ScoreType) -> float
Returns the weight for ScoreType <t>
examples(s):
scorefxn.get_weight(fa_sol)
See also:
ScoreFunction
ScoreFunction.set_weight
ScoreType
create_score_function
name_from_score_type
score_type_from_name
- has_nonzero_weight(...) from builtins.PyCapsule
- has_nonzero_weight(self : rosetta.core.scoring.ScoreFunction, t : rosetta.core.scoring.ScoreType) -> bool
Returns true if the ScoreType <t> has a non-zero weight
example(s):
scorefxn.has_nonzero_weight(fa_sol)
See also:
ScoreFunction
ScoreFunction.get_weight
ScoreFunction.has_zero_weight
ScoreFunction.set_weight
ScoreFunction.weights
ScoreType
create_score_function
name_from_score_type
score_type_from_name
- has_zero_weight(...) from builtins.PyCapsule
- has_zero_weight(self : rosetta.core.scoring.ScoreFunction, t : rosetta.core.scoring.ScoreType) -> bool
Returns true if the ScoreType <t> has a weight of zero,
example(s):
scorefxn.has_zero_weight(fa_sol)
See also:
ScoreFunction
ScoreFunction.get_weight
ScoreFunction.has_nonzero_weight
ScoreFunction.set_weight
ScoreFunction.weights
ScoreType
create_score_function
name_from_score_type
score_type_from_name
- indicate_required_context_graphs(...) from builtins.PyCapsule
- indicate_required_context_graphs(self : rosetta.core.scoring.ScoreFunction, context_graphs_required : rosetta.utility.vector1_bool) -> NoneType
find which context graphs the energy methods require
- info(...) from builtins.PyCapsule
- info(rosetta.core.scoring.ScoreFunction) -> core::scoring::ScoreFunctionInfo
return an object to describe abstractly the methods contained in this
ScoreFunction so that class Energies can ensure that the ScoreFunction is
properly evaluated (ie, no obsolete cashed data is used )
- initialize_from_file(...) from builtins.PyCapsule
- initialize_from_file(self : rosetta.core.scoring.ScoreFunction, filename : str) -> NoneType
Resets everything before reading the <filename>
- long_range_energies_begin(...) from builtins.PyCapsule
- long_range_energies_begin(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::LongRangeTwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::LongRangeTwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::LongRangeTwoBodyEnergy const> > > >
- long_range_energies_end(...) from builtins.PyCapsule
- long_range_energies_end(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::LongRangeTwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::LongRangeTwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::LongRangeTwoBodyEnergy const> > > >
- max_atomic_interaction_cutoff(...) from builtins.PyCapsule
- max_atomic_interaction_cutoff(rosetta.core.scoring.ScoreFunction) -> float
Returns the largest atomic interaction cutoff required by the
EnergyMethods
- merge(...) from builtins.PyCapsule
- merge(self : rosetta.core.scoring.ScoreFunction, scorefxn_to_be_merged : rosetta.core.scoring.ScoreFunction) -> NoneType
Merges in the weights of another score function
example(s):
scorefxn.merge(scorefxn2)
See also:
ScoreFunction
ScoreFunction.weights
Energies
create_score_function
- name(...) from builtins.PyCapsule
- name(self : rosetta.core.scoring.ScoreFunction, weights_tag : str) -> NoneType
Accumulates the unweighted one body energies of all context
independent one body energies for <pose> Residue <rsd> into
EnergyMap <emap>
: EnergyMap is an EMapVector
- perturb_weights(...) from builtins.PyCapsule
- perturb_weights(rosetta.core.scoring.ScoreFunction) -> NoneType
Randomly perturbs non-zero score function weights
- prepare_rotamers_for_packing(...) from builtins.PyCapsule
- prepare_rotamers_for_packing(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, set : rosetta.core.conformation.RotamerSetBase) -> NoneType
Lets the scoring functions cache anything they need to rapidly
calculate rotamer pair energies used in packing (like a trie, e.g.)
- ready_for_nonideal_scoring(...) from builtins.PyCapsule
- ready_for_nonideal_scoring(rosetta.core.scoring.ScoreFunction) -> bool
- reinitialize_minnode_for_residue(...) from builtins.PyCapsule
- reinitialize_minnode_for_residue(self : rosetta.core.scoring.ScoreFunction, min_node : core::scoring::MinimizationNode, rsd : rosetta.core.conformation.Residue, min_map : core::kinematics::MinimizerMapBase, pose : rosetta.core.pose.Pose) -> NoneType
- reset(...) from builtins.PyCapsule
- reset(rosetta.core.scoring.ScoreFunction) -> NoneType
Resets the ScoreFunction to default values
- reset_energy_methods(...) from builtins.PyCapsule
- reset_energy_methods(rosetta.core.scoring.ScoreFunction) -> NoneType
- score(...) from builtins.PyCapsule
- score(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose) -> float
Scores the given <pose> using this ScoreFunction. Alters the
Energies object within <pose>, but does not alter this ScoreFunction
: Synonym for () operator. Makes code look a little nicer. Doesn't
do anything but call () operator.
- score_by_scoretype(...) from builtins.PyCapsule
- score_by_scoretype(*args, **kwargs)
Overloaded function.
1. score_by_scoretype(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, t : rosetta.core.scoring.ScoreType) -> float
Returns the score of the ScoreType <t>
2. score_by_scoretype(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, t : rosetta.core.scoring.ScoreType, weighted : bool) -> float
Returns the score of the ScoreType <t>
- score_types_by_method_type(...) from builtins.PyCapsule
- score_types_by_method_type(self : rosetta.core.scoring.ScoreFunction, t : rosetta.core.scoring.methods.EnergyMethodType) -> rosetta.utility.vector1_core_scoring_ScoreType
- serialize_weights(...) from builtins.PyCapsule
- serialize_weights(rosetta.core.scoring.ScoreFunction) -> str
Serializes the non-zero score function term weights
Format: { term : weight, ... }
- set_energy_method_options(...) from builtins.PyCapsule
- set_energy_method_options(self : rosetta.core.scoring.ScoreFunction, energy_method_options_in : core::scoring::methods::EnergyMethodOptions) -> NoneType
Sets the EnergyMethodOptions object contained in this ScoreFunction.
with appropriate update of all the energy methods.
- set_etable(...) from builtins.PyCapsule
- set_etable(self : rosetta.core.scoring.ScoreFunction, etable_name : str) -> NoneType
Given a <filename> (represented by a std::string), set the
e_table for this ScoreFunction.
- set_method_weights(...) from builtins.PyCapsule
- set_method_weights(self : rosetta.core.scoring.ScoreFunction, t : rosetta.core.scoring.ScoreType, wts : rosetta.utility.vector1_double) -> NoneType
- set_weight(...) from builtins.PyCapsule
- set_weight(self : rosetta.core.scoring.ScoreFunction, t : rosetta.core.scoring.ScoreType, setting : float) -> NoneType
Sets the weight for ScoreType <t> to <setting>
example(s):
scorefxn.set_weight(fa_sol,.5)
See also:
ScoreFunction
ScoreFunction.get_weight
ScoreFunction.weights
ScoreType
create_score_function
name_from_score_type
score_type_from_name
- set_weight_if_zero(...) from builtins.PyCapsule
- set_weight_if_zero(self : rosetta.core.scoring.ScoreFunction, t : rosetta.core.scoring.ScoreType, setting : float) -> NoneType
Sets the weight for ScoreType <t> to <setting> if weight is originally zero
example(s):
scorefxn.set_weight_if_zero(fa_sol,.5)
See also:
ScoreFunction
ScoreFunction.get_weight
ScoreFunction.set_weight
ScoreType
create_score_function
name_from_score_type
score_type_from_name
- setup_for_lr2benmeth_minimization_for_respair(...) from builtins.PyCapsule
- setup_for_lr2benmeth_minimization_for_respair(*args, **kwargs)
Overloaded function.
1. setup_for_lr2benmeth_minimization_for_respair(self : rosetta.core.scoring.ScoreFunction, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, lr2benergy : core::scoring::methods::LongRangeTwoBodyEnergy, g : core::scoring::MinimizationGraph, min_map : core::kinematics::MinimizerMapBase, p : rosetta.core.pose.Pose, res_moving_wrt_eachother : bool, accumulate_fixed_energies : bool, rni : core::scoring::ResidueNeighborConstIterator, fixed_energies : rosetta.core.scoring.EMapVector) -> NoneType
Initialize an edge in the MinimizationGraph with a particular long-range two body
2. setup_for_lr2benmeth_minimization_for_respair(self : rosetta.core.scoring.ScoreFunction, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, lr2benergy : core::scoring::methods::LongRangeTwoBodyEnergy, g : core::scoring::MinimizationGraph, min_map : core::kinematics::MinimizerMapBase, p : rosetta.core.pose.Pose, res_moving_wrt_eachother : bool, accumulate_fixed_energies : bool, rni : core::scoring::ResidueNeighborConstIterator, fixed_energies : rosetta.core.scoring.EMapVector, edge_weight : float) -> NoneType
Initialize an edge in the MinimizationGraph with a particular long-range two body
3. setup_for_lr2benmeth_minimization_for_respair(self : rosetta.core.scoring.ScoreFunction, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, lr2benergy : core::scoring::methods::LongRangeTwoBodyEnergy, g : core::scoring::MinimizationGraph, min_map : core::kinematics::MinimizerMapBase, p : rosetta.core.pose.Pose, res_moving_wrt_eachother : bool, accumulate_fixed_energies : bool, rni : core::scoring::ResidueNeighborConstIterator, fixed_energies : rosetta.core.scoring.EMapVector, edge_weight : float, edge_dweight : float) -> NoneType
Initialize an edge in the MinimizationGraph with a particular long-range two body
- setup_for_minimizing_for_node(...) from builtins.PyCapsule
- setup_for_minimizing_for_node(self : rosetta.core.scoring.ScoreFunction, min_node : core::scoring::MinimizationNode, rsd : rosetta.core.conformation.Residue, min_map : core::kinematics::MinimizerMapBase, pose : rosetta.core.pose.Pose, accumulate_fixed_energies : bool, fixed_energies : rosetta.core.scoring.EMapVector) -> NoneType
Initialize a single node of a MinimizationGraph with the one-body and two-body
energy methods that are held within this ScoreFunction object.
- setup_for_minimizing_sr2b_enmeths_for_minedge(...) from builtins.PyCapsule
- setup_for_minimizing_sr2b_enmeths_for_minedge(*args, **kwargs)
Overloaded function.
1. setup_for_minimizing_sr2b_enmeths_for_minedge(self : rosetta.core.scoring.ScoreFunction, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, min_edge : core::scoring::MinimizationEdge, min_map : core::kinematics::MinimizerMapBase, pose : rosetta.core.pose.Pose, res_moving_wrt_eachother : bool, accumulate_fixed_energies : bool, energy_edge : core::scoring::EnergyEdge, fixed_energies : rosetta.core.scoring.EMapVector) -> NoneType
Initialize a single MinimizationEdge for a particular part of residues, storing
sr2b energy method pointers on the edge for those sr2b energy methods in this ScoreFunction
2. setup_for_minimizing_sr2b_enmeths_for_minedge(self : rosetta.core.scoring.ScoreFunction, res1 : rosetta.core.conformation.Residue, res2 : rosetta.core.conformation.Residue, min_edge : core::scoring::MinimizationEdge, min_map : core::kinematics::MinimizerMapBase, pose : rosetta.core.pose.Pose, res_moving_wrt_eachother : bool, accumulate_fixed_energies : bool, energy_edge : core::scoring::EnergyEdge, fixed_energies : rosetta.core.scoring.EMapVector, edge_weight : float) -> NoneType
Initialize a single MinimizationEdge for a particular part of residues, storing
sr2b energy method pointers on the edge for those sr2b energy methods in this ScoreFunction
- setup_for_packing(...) from builtins.PyCapsule
- setup_for_packing(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, residues_repacking : rosetta.utility.vector1_bool, residues_designing : rosetta.utility.vector1_bool) -> NoneType
Lets the scoring functions cache anything they need to calculate
energies in a packing step (rotamer_trials or pack_rotamers)
: the Etable caches tries for each of the residues, the
hydrogen bond function caches backbone/backbone hydrogen bonds
- setup_for_scoring(...) from builtins.PyCapsule
- setup_for_scoring(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
For external scorers: Let the energy methods prepare for
evaluating their scores on a particular structure
: invoked during scoring.
- show(...) from builtins.PyCapsule
- show(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
Scores <pose> and shows the raw and weighted scores for each
non-zero ScoreType
: this function is mostly for convenience in PyRosetta
example(s):
scorefxn.show(pose)
See also:
ScoreFunction
ScoreFunction.weights
Energies
create_score_function
- update_residue_for_packing(...) from builtins.PyCapsule
- update_residue_for_packing(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, resid : int) -> NoneType
If inside packing, the pose changes conformation, inform the
scoring functions that any data they have cached in the Energies object
is out of date. In particular, this is to update the trie(s) during
rotamer trials.
- weights(...) from builtins.PyCapsule
- weights(rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.EMapVector
Returns an EnergyMap of the current set of weights
example(s):
scorefxn.weights()
See also:
ScoreFunction
ScoreFunction.get_weight
ScoreFunction.set_weight
ScoreFunction.weights
ScoreType
create_score_function
name_from_score_type
score_type_from_name
- whole_structure_types(...) from builtins.PyCapsule
- whole_structure_types(rosetta.core.scoring.ScoreFunction) -> rosetta.utility.vector1_core_scoring_ScoreType
- ws_methods_begin(...) from builtins.PyCapsule
- ws_methods_begin(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::WholeStructureEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::WholeStructureEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::WholeStructureEnergy> > > >
- ws_methods_end(...) from builtins.PyCapsule
- ws_methods_end(rosetta.core.scoring.ScoreFunction) -> __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::WholeStructureEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::WholeStructureEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::WholeStructureEnergy> > > >
| |