| | |
- rosetta.core.scoring.ScoreFunction(builtins.object)
-
- OtherContextScoreFunction
- rosetta.protocols.moves.Mover(builtins.object)
-
- FlexPacker
class FlexPacker(rosetta.protocols.moves.Mover) |
| | |
- Method resolution order:
- FlexPacker
- rosetta.protocols.moves.Mover
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(self : handle, task : rosetta.core.pack.task.PackerTask, frames : rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t, scorefxn : rosetta.core.scoring.ScoreFunction) -> NoneType
2. __init__(handle, rosetta.protocols.flexpack.FlexPacker) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- apply(...) from builtins.PyCapsule
- apply(self : rosetta.protocols.flexpack.FlexPacker, pose : rosetta.core.pose.Pose) -> NoneType
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.protocols.flexpack.FlexPacker, : rosetta.protocols.flexpack.FlexPacker) -> rosetta.protocols.flexpack.FlexPacker
- get_name(...) from builtins.PyCapsule
- get_name(rosetta.protocols.flexpack.FlexPacker) -> str
- set_frames(...) from builtins.PyCapsule
- set_frames(self : rosetta.protocols.flexpack.FlexPacker, frames : rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) -> NoneType
- set_sfxn(...) from builtins.PyCapsule
- set_sfxn(self : rosetta.protocols.flexpack.FlexPacker, sfxn : rosetta.core.scoring.ScoreFunction) -> NoneType
- set_task(...) from builtins.PyCapsule
- set_task(self : rosetta.protocols.flexpack.FlexPacker, task : rosetta.core.pack.task.PackerTask) -> NoneType
- set_task_factory(...) from builtins.PyCapsule
- set_task_factory(self : rosetta.protocols.flexpack.FlexPacker, factory : rosetta.core.pack.task.TaskFactory) -> NoneType
Methods inherited from rosetta.protocols.moves.Mover:
- clear_info(...) from builtins.PyCapsule
- clear_info(rosetta.protocols.moves.Mover) -> NoneType
Strings container can be used to return miscellaneous info (as std::string) from a mover, such as notes about the results of apply(). The job distributor (Apr 09 vintage) will check this function to see if your protocol wants to add string info to the Job that ran this mover. One way this can be useful is that later, a JobOutputter may include/append this info to an output file.
clear_info is called by jd2 before calling apply
- clone(...) from builtins.PyCapsule
- clone(rosetta.protocols.moves.Mover) -> rosetta.protocols.moves.Mover
Return a clone of the Mover object.
- create(...) from builtins.PyCapsule
- create(rosetta.protocols.moves.Mover) -> rosetta.protocols.moves.Mover
- fresh_instance(...) from builtins.PyCapsule
- fresh_instance(rosetta.protocols.moves.Mover) -> rosetta.protocols.moves.Mover
Generates a new Mover object freshly created with the default ctor.
- get_additional_output(...) from builtins.PyCapsule
- get_additional_output(rosetta.protocols.moves.Mover) -> rosetta.core.pose.Pose
fpd
Mechanism by which a mover may return multiple output poses from a single input pose.
- get_current_job(...) from builtins.PyCapsule
- get_current_job(rosetta.protocols.moves.Mover) -> protocols::jobdist::BasicJob
- get_current_tag(...) from builtins.PyCapsule
- get_current_tag(rosetta.protocols.moves.Mover) -> str
A tag is a unique identifier used to identify structures produced
by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag )
sets the tag. This functionality is not intended for use with the 2008 job distributor.
- get_input_pose(...) from builtins.PyCapsule
- get_input_pose(rosetta.protocols.moves.Mover) -> rosetta.core.pose.Pose
- get_last_move_status(...) from builtins.PyCapsule
- get_last_move_status(rosetta.protocols.moves.Mover) -> rosetta.protocols.moves.MoverStatus
returns status after an apply(). The job distributor (august 08 vintage) will check this function to see if your protocol wants to filter its results - if your protocol wants to say "that run was no good, skip it" then use the protected last_move_status(MoverStatus) to change the value that this function will return.
- get_native_pose(...) from builtins.PyCapsule
- get_native_pose(rosetta.protocols.moves.Mover) -> rosetta.core.pose.Pose
- get_self_ptr(...) from builtins.PyCapsule
- get_self_ptr(*args, **kwargs)
Overloaded function.
1. get_self_ptr(rosetta.protocols.moves.Mover) -> rosetta.protocols.moves.Mover
2. get_self_ptr(rosetta.protocols.moves.Mover) -> rosetta.protocols.moves.Mover
- get_self_weak_ptr(...) from builtins.PyCapsule
- get_self_weak_ptr(*args, **kwargs)
Overloaded function.
1. get_self_weak_ptr(rosetta.protocols.moves.Mover) -> rosetta.std.weak_ptr_const_protocols_moves_Mover_t
2. get_self_weak_ptr(rosetta.protocols.moves.Mover) -> rosetta.std.weak_ptr_protocols_moves_Mover_t
- get_type(...) from builtins.PyCapsule
- get_type(rosetta.protocols.moves.Mover) -> str
- info(...) from builtins.PyCapsule
- info(*args, **kwargs)
Overloaded function.
1. info(rosetta.protocols.moves.Mover) -> rosetta.std.list_std_string_std_allocator_std_string_t
non-const accessor
2. info(rosetta.protocols.moves.Mover) -> rosetta.std.list_std_string_std_allocator_std_string_t
const accessor
- last_proposal_density_ratio(...) from builtins.PyCapsule
- last_proposal_density_ratio(rosetta.protocols.moves.Mover) -> float
- name(...) from builtins.PyCapsule
- name() -> str
- register_options(...) from builtins.PyCapsule
- register_options(*args, **kwargs)
Overloaded function.
1. register_options() -> NoneType
Overload this static method if you access options within the mover.
These options will end up in -help of your application if users of this mover call register_options.
Do this recursively!
If you use movers within your mover, call their register_options in your register_options() method.
2. register_options() -> NoneType
3. register_options() -> NoneType
4. register_options() -> NoneType
5. register_options() -> NoneType
6. register_options() -> NoneType
7. register_options() -> NoneType
8. register_options() -> NoneType
9. register_options() -> NoneType
Associates relevant options with the AntibodyModeler class
10. register_options() -> NoneType
Associates relevant options with the AntibodyModeler class
11. register_options() -> NoneType
Associates relevant options with the SnugDock class
12. register_options() -> NoneType
Associates relevant options with the SnugDockProtocol class
13. register_options() -> NoneType
Register the options used by this mover with the global options
system.
14. register_options() -> NoneType
15. register_options() -> NoneType
Associate relevant options with the TemperedDocking class.
16. register_options() -> NoneType
17. register_options() -> NoneType
18. register_options() -> NoneType
Associates relevant options with the TemperedDocking class.
19. register_options() -> NoneType
20. register_options() -> NoneType
Associates relevant options with the ConstraintSetMover class
21. register_options() -> NoneType
22. register_options() -> NoneType
Associates relevant options with the DockingInitialPerturbation class
23. register_options() -> NoneType
Associates relevant options with the DockingProtocol class
24. register_options() -> NoneType
Associates relevant options with the TemperedDocking class
25. register_options() -> NoneType
26. register_options() -> NoneType
27. register_options() -> NoneType
28. register_options() -> NoneType
register options
29. register_options() -> NoneType
30. register_options() -> NoneType
Registers applicable options
31. register_options() -> NoneType
Register options with the option system.
32. register_options() -> NoneType
33. register_options() -> NoneType
34. register_options() -> NoneType
Associates relevant options with the LoopRefineInnerCycle class
35. register_options() -> NoneType
Associates relevant options with the LoopRefineInnerCycleContainer class
36. register_options() -> NoneType
Associates relevant options with the LoopRefineInnerCycle class
37. register_options() -> NoneType
Associates relevant options with the LoopRefineInnerCycle class
38. register_options() -> NoneType
39. register_options() -> NoneType
Register options with the option system.
40. register_options() -> NoneType
- reinitialize_for_each_job(...) from builtins.PyCapsule
- reinitialize_for_each_job(rosetta.protocols.moves.Mover) -> bool
Inform the Job Distributor (August '08 vintage) whether this object needs to be freshly regenerated on
each use.
- reinitialize_for_new_input(...) from builtins.PyCapsule
- reinitialize_for_new_input(rosetta.protocols.moves.Mover) -> bool
Inform the Job Distributor (August '08 vintage) whether this object needs to be regenerated when the input
pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for
that one input pose).
- reset_status(...) from builtins.PyCapsule
- reset_status(rosetta.protocols.moves.Mover) -> NoneType
resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.
- set_current_job(...) from builtins.PyCapsule
- set_current_job(self : rosetta.protocols.moves.Mover, job : protocols::jobdist::BasicJob) -> NoneType
////////////////////////////end Job Distributor interface////////////////////////////////////////
- set_current_tag(...) from builtins.PyCapsule
- set_current_tag(self : rosetta.protocols.moves.Mover, new_tag : str) -> NoneType
- set_input_pose(...) from builtins.PyCapsule
- set_input_pose(self : rosetta.protocols.moves.Mover, pose : rosetta.core.pose.Pose) -> NoneType
setter for poses contained for rms
- set_native_pose(...) from builtins.PyCapsule
- set_native_pose(self : rosetta.protocols.moves.Mover, pose : rosetta.core.pose.Pose) -> NoneType
setter for native poses contained for rms ---- we should get rid of this method? it is widely used, but a bit unsafe
- set_type(...) from builtins.PyCapsule
- set_type(self : rosetta.protocols.moves.Mover, setting : str) -> NoneType
- test_move(...) from builtins.PyCapsule
- test_move(self : rosetta.protocols.moves.Mover, pose : rosetta.core.pose.Pose) -> NoneType
: Unit test support function. Apply one move to a given pose.
Allows extra test specific functions to be called before applying
- type(...) from builtins.PyCapsule
- type(*args, **kwargs)
Overloaded function.
1. type(rosetta.protocols.moves.Mover) -> str
2. type(self : rosetta.protocols.moves.Mover, type_in : str) -> NoneType
|
class OtherContextScoreFunction(rosetta.core.scoring.ScoreFunction) |
| | |
- Method resolution order:
- OtherContextScoreFunction
- rosetta.core.scoring.ScoreFunction
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(self : handle, context_pose : rosetta.core.pose.Pose) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- eval_cd_1b(...) from builtins.PyCapsule
- eval_cd_1b(self : rosetta.protocols.flexpack.OtherContextScoreFunction, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
- eval_cd_2b(...) from builtins.PyCapsule
- eval_cd_2b(self : rosetta.protocols.flexpack.OtherContextScoreFunction, rsd1 : rosetta.core.conformation.Residue, rsd2 : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
accumulate unweighted interaction energies between rsd1 and rsd2
for all short ranged context dependent two body energies contained in this scorefunction
- eval_cd_intrares_energy(...) from builtins.PyCapsule
- eval_cd_intrares_energy(self : rosetta.protocols.flexpack.OtherContextScoreFunction, rsd : rosetta.core.conformation.Residue, pose : rosetta.core.pose.Pose, emap : rosetta.core.scoring.EMapVector) -> NoneType
- pre_scoring(...) from builtins.PyCapsule
- pre_scoring(rosetta.protocols.flexpack.OtherContextScoreFunction) -> NoneType
- set_context_pose(...) from builtins.PyCapsule
- set_context_pose(self : rosetta.protocols.flexpack.OtherContextScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
Methods inherited from rosetta.core.scoring.ScoreFunction:
- __call__(...) from builtins.PyCapsule
- __call__(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
- __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
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.core.scoring.ScoreFunction, 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.
- 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(...) from builtins.PyCapsule
- clone(rosetta.core.scoring.ScoreFunction) -> rosetta.core.scoring.ScoreFunction
Create a copy of the scorefunction
Virtual to keep subclass information.
- 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_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_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_dof_derivative(...) from builtins.PyCapsule
- eval_dof_derivative(self : rosetta.core.scoring.ScoreFunction, dof_id : rosetta.core.id.DOF_ID, torsion_id : core::id::TorsionID, pose : rosetta.core.pose.Pose) -> float
- 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
- eval_long_range_twobody_energies(...) from builtins.PyCapsule
- eval_long_range_twobody_energies(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
- eval_npd_atom_derivative(...) from builtins.PyCapsule
- eval_npd_atom_derivative(self : rosetta.core.scoring.ScoreFunction, 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.ScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
- eval_twobody_neighbor_energies(...) from builtins.PyCapsule
- eval_twobody_neighbor_energies(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
- 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_derivatives(...) from builtins.PyCapsule
- setup_for_derivatives(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose) -> NoneType
- 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(...) from builtins.PyCapsule
- setup_for_minimizing(self : rosetta.core.scoring.ScoreFunction, pose : rosetta.core.pose.Pose, min_map : core::kinematics::MinimizerMapBase) -> NoneType
Initializes a MinimizationGraph and caches it in
Energies object of <pose>
: for use during minimization
- 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> > > >
| |