flexpack

Bindings for protocols::flexpack namespace

class pyrosetta.rosetta.protocols.flexpack.FlexPacker

Bases: pyrosetta.rosetta.protocols.moves.Mover

apply(self: pyrosetta.rosetta.protocols.flexpack.FlexPacker, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: protocols::flexpack::FlexPacker::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.flexpack.FlexPacker, : pyrosetta.rosetta.protocols.flexpack.FlexPacker) pyrosetta.rosetta.protocols.flexpack.FlexPacker

C++: protocols::flexpack::FlexPacker::operator=(const class protocols::flexpack::FlexPacker &) –> class protocols::flexpack::FlexPacker &

clear_info(self: pyrosetta.rosetta.protocols.moves.Mover) None

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

C++: protocols::moves::Mover::clear_info() –> void

clone(self: pyrosetta.rosetta.protocols.moves.Mover) pyrosetta.rosetta.protocols.moves.Mover

Return a clone of the Mover object.

C++: protocols::moves::Mover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

create(self: pyrosetta.rosetta.protocols.moves.Mover) pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

fresh_instance(self: pyrosetta.rosetta.protocols.moves.Mover) pyrosetta.rosetta.protocols.moves.Mover

Generates a new Mover object freshly created with the default ctor.

C++: protocols::moves::Mover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

get_additional_output(self: pyrosetta.rosetta.protocols.moves.Mover) pyrosetta.rosetta.core.pose.Pose

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

Supported in JD2. Will attempt to grab additional poses until a nullptr is returned.

C++: protocols::moves::Mover::get_additional_output() –> class std::shared_ptr<class core::pose::Pose>

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) protocols::jobdist::BasicJob

C++: protocols::moves::Mover::get_current_job() const –> class std::shared_ptr<const class protocols::jobdist::BasicJob>

get_current_tag(self: pyrosetta.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.

C++: protocols::moves::Mover::get_current_tag() const –> std::string

get_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover) pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_input_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_last_move_status(self: pyrosetta.rosetta.protocols.moves.Mover) pyrosetta.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.

C++: protocols::moves::Mover::get_last_move_status() const –> enum protocols::moves::MoverStatus

get_name(self: pyrosetta.rosetta.protocols.flexpack.FlexPacker) str

C++: protocols::flexpack::FlexPacker::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_type(self: pyrosetta.rosetta.protocols.moves.Mover) str

C++: protocols::moves::Mover::get_type() const –> std::string

info(self: pyrosetta.rosetta.protocols.moves.Mover) pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

non-const accessor

C++: protocols::moves::Mover::info() –> class std::list<std::string, class std::allocator<std::string > > &

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

static name() str

C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.moves.Mover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) None

Called by MoverFactory when constructing new Movers. Takes care of the specific mover’s parsing.

C++: protocols::moves::Mover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.moves.Mover, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) None
Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by movers wishing to provide citation information.

C++: protocols::moves::Mover::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static register_options() None

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.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) bool
Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.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).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) None

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.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) None

C++: protocols::moves::Mover::set_current_job(class std::shared_ptr<const class protocols::jobdist::BasicJob>) –> void

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) None

C++: protocols::moves::Mover::set_current_tag(const std::string &) –> void

set_frames(self: pyrosetta.rosetta.protocols.flexpack.FlexPacker, frames: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_fragment_Frame_t) None

C++: protocols::flexpack::FlexPacker::set_frames(const class utility::vector1<class std::shared_ptr<class core::fragment::Frame>, class std::allocator<class std::shared_ptr<class core::fragment::Frame> > > &) –> void

set_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) None

setter for poses contained for rms

C++: protocols::moves::Mover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) None

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

C++: protocols::moves::Mover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_sfxn(self: pyrosetta.rosetta.protocols.flexpack.FlexPacker, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: protocols::flexpack::FlexPacker::set_sfxn(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_task(self: pyrosetta.rosetta.protocols.flexpack.FlexPacker, task: pyrosetta.rosetta.core.pack.task.PackerTask) None

C++: protocols::flexpack::FlexPacker::set_task(class std::shared_ptr<const class core::pack::task::PackerTask>) –> void

set_task_factory(self: pyrosetta.rosetta.protocols.flexpack.FlexPacker, factory: pyrosetta.rosetta.core.pack.task.TaskFactory) None

C++: protocols::flexpack::FlexPacker::set_task_factory(class std::shared_ptr<class core::pack::task::TaskFactory>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) None

Set the ‘type’ string

C++: protocols::moves::Mover::set_type(const std::string &) –> void

show(*args, **kwargs)

Overloaded function.

  1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None

  2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

C++: protocols::moves::Mover::show(std::ostream &) const –> void

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) None
: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

  1. type(self: pyrosetta.rosetta.protocols.moves.Mover, type_in: str) -> None

Set the ‘type’ string

C++: protocols::moves::Mover::type(const std::string &) –> void

  1. type(self: pyrosetta.rosetta.protocols.moves.Mover) -> str

Get the set ‘type’ string

C++: protocols::moves::Mover::type() const –> const std::string &

class pyrosetta.rosetta.protocols.flexpack.OtherContextScoreFunction

Bases: pyrosetta.rosetta.core.scoring.ScoreFunction

_add_weights_from_file(*args, **kwargs)

Overloaded function.

  1. _add_weights_from_file(self: pyrosetta.rosetta.core.scoring.ScoreFunction, filename: str) -> None

  2. _add_weights_from_file(self: pyrosetta.rosetta.core.scoring.ScoreFunction, filename: str, patch: bool) -> None

Initializes this ScoreFunction from the given <filename>

no lookup in database directory

C++: core::scoring::ScoreFunction::_add_weights_from_file(const std::string &, bool) –> void

_add_weights_from_stream(*args, **kwargs)

Overloaded function.

  1. _add_weights_from_stream(self: pyrosetta.rosetta.core.scoring.ScoreFunction, data: pyrosetta.rosetta.std.istream) -> None

  2. _add_weights_from_stream(self: pyrosetta.rosetta.core.scoring.ScoreFunction, data: pyrosetta.rosetta.std.istream, patch: bool) -> None

  3. _add_weights_from_stream(self: pyrosetta.rosetta.core.scoring.ScoreFunction, data: pyrosetta.rosetta.std.istream, patch: bool, filename: str) -> None

C++: core::scoring::ScoreFunction::_add_weights_from_stream(std::istream &, bool, const std::string &) –> void

add_extra_method(*args, **kwargs)

Overloaded function.

  1. add_extra_method(self: pyrosetta.rosetta.core.scoring.ScoreFunction, new_type: pyrosetta.rosetta.core.scoring.ScoreType, new_weight: float, new_method: pyrosetta.rosetta.core.scoring.methods.EnergyMethod) -> None

Adds a scoring method that is not necessarily included in

the core library

C++: core::scoring::ScoreFunction::add_extra_method(const enum core::scoring::ScoreType &, const double, const class core::scoring::methods::EnergyMethod &) –> void

  1. add_extra_method(self: pyrosetta.rosetta.core.scoring.ScoreFunction, new_weights: pyrosetta.rosetta.std.map_core_scoring_ScoreType_double, new_method: pyrosetta.rosetta.core.scoring.methods.EnergyMethod) -> None

Adds a scoring method that is not necessarily included in

the core library

C++: core::scoring::ScoreFunction::add_extra_method(const class std::map<enum core::scoring::ScoreType, double, struct std::less<enum core::scoring::ScoreType>, class std::allocator<struct std::pair<const enum core::scoring::ScoreType, double> > > &, const class core::scoring::methods::EnergyMethod &) –> void

add_to_weight(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.rosetta.core.scoring.ScoreType, increment: float) None

Increments the weight for ScoreType <t> by <setting>

example(s):

scorefxn.add_to_weight(fa_sol,.5)

See also:

ScoreFunction ScoreFunction.get_weight ScoreFunction.set_weight ScoreType name_from_score_type score_type_from_name

C++: core::scoring::ScoreFunction::add_to_weight(const enum core::scoring::ScoreType &, const double &) –> void

add_weights_from_file(self: pyrosetta.rosetta.core.scoring.ScoreFunction, filename: str) None

Initializes this ScoreFunction from the given <filename>

C++: core::scoring::ScoreFunction::add_weights_from_file(const std::string &) –> void

all_energies_begin(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::all_energies_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::EnergyMethod> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::EnergyMethod>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::EnergyMethod> > > >

all_energies_end(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::all_energies_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::EnergyMethod> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::EnergyMethod>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::EnergyMethod> > > >

all_methods(self: pyrosetta.rosetta.core.scoring.ScoreFunction) pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_methods_EnergyMethod_t

C++: core::scoring::ScoreFunction::all_methods() const –> const class utility::vector1<class std::shared_ptr<const class core::scoring::methods::EnergyMethod>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::EnergyMethod> > > &

any_lr_residue_pair_energy(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, res1: int, res2: int) bool

C++: core::scoring::ScoreFunction::any_lr_residue_pair_energy(const class core::pose::Pose &, unsigned long, unsigned long) const –> bool

apply_patch_from_file(self: pyrosetta.rosetta.core.scoring.ScoreFunction, filename: str) None

Applies a patch from the given <filename>

C++: core::scoring::ScoreFunction::apply_patch_from_file(const std::string &) –> void

are_they_neighbors(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, pos1: int, pos2: int) bool
Returns true if the <pose> positions <pos1> and <pos2>

are neighbors

C++: core::scoring::ScoreFunction::are_they_neighbors(const class core::pose::Pose &, const unsigned long, const unsigned long) const –> bool

assign(self: pyrosetta.rosetta.core.scoring.ScoreFunction, src: pyrosetta.rosetta.core.scoring.ScoreFunction) None
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.

C++: core::scoring::ScoreFunction::assign(const class core::scoring::ScoreFunction &) –> void

bump_check_backbone(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None
Scores the sidechain from <pose> Residue <rsd1> against the

backbone of Residue <rsd2>

C++: core::scoring::ScoreFunction::bump_check_backbone(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

bump_check_full(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None

C++: core::scoring::ScoreFunction::bump_check_full(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

cd_1b_methods_begin(self: pyrosetta.rosetta.core.scoring.ScoreFunction) __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextDependentOneBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextDependentOneBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextDependentOneBodyEnergy> > > >

C++: core::scoring::ScoreFunction::cd_1b_methods_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextDependentOneBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextDependentOneBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextDependentOneBodyEnergy> > > >

cd_1b_methods_end(self: pyrosetta.rosetta.core.scoring.ScoreFunction) __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextDependentOneBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextDependentOneBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextDependentOneBodyEnergy> > > >

C++: core::scoring::ScoreFunction::cd_1b_methods_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextDependentOneBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextDependentOneBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextDependentOneBodyEnergy> > > >

cd_1b_types(self: pyrosetta.rosetta.core.scoring.ScoreFunction) pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

convenience access to all cd 1b score types

C++: core::scoring::ScoreFunction::cd_1b_types() const –> const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &

cd_2b_begin(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::cd_2b_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextDependentTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextDependentTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextDependentTwoBodyEnergy> > > >

cd_2b_end(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::cd_2b_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextDependentTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextDependentTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextDependentTwoBodyEnergy> > > >

cd_2b_intrares_begin(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::cd_2b_intrares_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> > > >

cd_2b_intrares_end(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::cd_2b_intrares_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> > > >

cd_2b_types(self: pyrosetta.rosetta.core.scoring.ScoreFunction) pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

convenience access to all cd 2b score types

C++: core::scoring::ScoreFunction::cd_2b_types() const –> const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &

cd_lr_2b_methods_begin(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::cd_lr_2b_methods_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextDependentLRTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextDependentLRTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextDependentLRTwoBodyEnergy> > > >

cd_lr_2b_methods_end(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::cd_lr_2b_methods_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextDependentLRTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextDependentLRTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextDependentLRTwoBodyEnergy> > > >

cd_lr_2b_types(self: pyrosetta.rosetta.core.scoring.ScoreFunction) pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

C++: core::scoring::ScoreFunction::cd_lr_2b_types() const –> const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &

check_methods_in_right_order(self: pyrosetta.rosetta.core.scoring.ScoreFunction, score_type_in_first_method: pyrosetta.rosetta.core.scoring.ScoreType, score_type_in_second_method: pyrosetta.rosetta.core.scoring.ScoreType) bool

check order of methods

C++: core::scoring::ScoreFunction::check_methods_in_right_order(const enum core::scoring::ScoreType &, const enum core::scoring::ScoreType &) const –> bool

ci_1b_methods_begin(self: pyrosetta.rosetta.core.scoring.ScoreFunction) __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextIndependentOneBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextIndependentOneBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextIndependentOneBodyEnergy> > > >

C++: core::scoring::ScoreFunction::ci_1b_methods_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextIndependentOneBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextIndependentOneBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextIndependentOneBodyEnergy> > > >

ci_1b_methods_end(self: pyrosetta.rosetta.core.scoring.ScoreFunction) __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextIndependentOneBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextIndependentOneBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextIndependentOneBodyEnergy> > > >

C++: core::scoring::ScoreFunction::ci_1b_methods_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextIndependentOneBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextIndependentOneBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextIndependentOneBodyEnergy> > > >

ci_1b_types(self: pyrosetta.rosetta.core.scoring.ScoreFunction) pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

convenience access to all ci 1b score types

C++: core::scoring::ScoreFunction::ci_1b_types() const –> const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &

ci_2b_begin(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::ci_2b_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextIndependentTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextIndependentTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextIndependentTwoBodyEnergy> > > >

ci_2b_end(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::ci_2b_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextIndependentTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextIndependentTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextIndependentTwoBodyEnergy> > > >

ci_2b_intrares_begin(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::ci_2b_intrares_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> > > >

ci_2b_intrares_end(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::ci_2b_intrares_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> > > >

ci_2b_types(self: pyrosetta.rosetta.core.scoring.ScoreFunction) pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

convenience access to all ci 2b score types

C++: core::scoring::ScoreFunction::ci_2b_types() const –> const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &

ci_lr_2b_methods_begin(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::ci_lr_2b_methods_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextIndependentLRTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextIndependentLRTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextIndependentLRTwoBodyEnergy> > > >

ci_lr_2b_methods_end(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::ci_lr_2b_methods_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextIndependentLRTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextIndependentLRTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextIndependentLRTwoBodyEnergy> > > >

ci_lr_2b_types(self: pyrosetta.rosetta.core.scoring.ScoreFunction) pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

C++: core::scoring::ScoreFunction::ci_lr_2b_types() const –> const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &

clone(self: pyrosetta.rosetta.core.scoring.ScoreFunction) pyrosetta.rosetta.core.scoring.ScoreFunction
Create a copy of the scorefunction

Virtual to keep subclass information.

C++: core::scoring::ScoreFunction::clone() const –> class std::shared_ptr<class core::scoring::ScoreFunction>

clone_as_base_class(self: pyrosetta.rosetta.core.scoring.ScoreFunction) pyrosetta.rosetta.core.scoring.ScoreFunction

If you want to discard subclass information, the following function is availible

C++: core::scoring::ScoreFunction::clone_as_base_class() const –> class std::shared_ptr<class core::scoring::ScoreFunction>

energy_method_options(self: pyrosetta.rosetta.core.scoring.ScoreFunction) pyrosetta.rosetta.core.scoring.methods.EnergyMethodOptions
Returns the EnergyMethodOptions object contained in this

ScoreFunction (const access)

C++: core::scoring::ScoreFunction::energy_method_options() const –> const class core::scoring::methods::EnergyMethodOptions &

eval_cd_1b(self: pyrosetta.rosetta.protocols.flexpack.OtherContextScoreFunction, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None

C++: protocols::flexpack::OtherContextScoreFunction::eval_cd_1b(const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_cd_2b(self: pyrosetta.rosetta.protocols.flexpack.OtherContextScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None
accumulate unweighted interaction energies between rsd1 and rsd2

for all short ranged context dependent two body energies contained in this scorefunction

C++: protocols::flexpack::OtherContextScoreFunction::eval_cd_2b(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_cd_2b_bb_bb(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None
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

C++: core::scoring::ScoreFunction::eval_cd_2b_bb_bb(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_cd_2b_bb_sc(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None
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

C++: core::scoring::ScoreFunction::eval_cd_2b_bb_sc(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_cd_2b_sc_sc(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None
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

C++: core::scoring::ScoreFunction::eval_cd_2b_sc_sc(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_cd_intrares_energy(self: pyrosetta.rosetta.protocols.flexpack.OtherContextScoreFunction, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None

C++: protocols::flexpack::OtherContextScoreFunction::eval_cd_intrares_energy(const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_ci_1b(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None

C++: core::scoring::ScoreFunction::eval_ci_1b(const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_ci_2b(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None
Accumulates the unweighted context independent two body

interaction energies of <pose> between Residue <rsd1> and Residue <rsd2> into EnergyMap <emap>

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::eval_ci_2b(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_ci_2b_bb_bb(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None
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

C++: core::scoring::ScoreFunction::eval_ci_2b_bb_bb(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_ci_2b_bb_sc(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None
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

C++: core::scoring::ScoreFunction::eval_ci_2b_bb_sc(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_ci_2b_sc_sc(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None
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

C++: core::scoring::ScoreFunction::eval_ci_2b_sc_sc(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_ci_intrares_energy(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None
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

C++: core::scoring::ScoreFunction::eval_ci_intrares_energy(const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_dof_derivative(self: pyrosetta.rosetta.core.scoring.ScoreFunction, dof_id: pyrosetta.rosetta.core.id.DOF_ID, torsion_id: core::id::TorsionID, pose: pyrosetta.rosetta.core.pose.Pose) float

C++: core::scoring::ScoreFunction::eval_dof_derivative(const class core::id::DOF_ID &, const class core::id::TorsionID &, const class core::pose::Pose &) const –> double

eval_intrares_energy(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) None
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

C++: core::scoring::ScoreFunction::eval_intrares_energy(const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_long_range_twobody_energies(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::ScoreFunction::eval_long_range_twobody_energies(class core::pose::Pose &) const –> void

eval_npd_atom_derivative(self: pyrosetta.rosetta.core.scoring.ScoreFunction, atom_id: pyrosetta.rosetta.core.id.AtomID, pose: pyrosetta.rosetta.core.pose.Pose, domain_map: pyrosetta.rosetta.ObjexxFCL.FArray1D_int_t, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) None

C++: core::scoring::ScoreFunction::eval_npd_atom_derivative(const class core::id::AtomID &, const class core::pose::Pose &, const class ObjexxFCL::FArray1D<int> &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

eval_onebody_energies(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::ScoreFunction::eval_onebody_energies(class core::pose::Pose &) const –> void

eval_twobody_neighbor_energies(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::ScoreFunction::eval_twobody_neighbor_energies(class core::pose::Pose &) const –> void

evaluate_rotamer_background_energies(self: pyrosetta.rosetta.core.scoring.ScoreFunction, set1: pyrosetta.rosetta.core.conformation.RotamerSetBase, residue2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, energy_vector: pyrosetta.rosetta.utility.vector1_float) None

C++: core::scoring::ScoreFunction::evaluate_rotamer_background_energies(const class core::conformation::RotamerSetBase &, const class core::conformation::Residue &, const class core::pose::Pose &, class utility::vector1<float, class std::allocator<float> > &) const –> void

evaluate_rotamer_intrares_energies(self: pyrosetta.rosetta.core.scoring.ScoreFunction, set: pyrosetta.rosetta.core.conformation.RotamerSetBase, pose: pyrosetta.rosetta.core.pose.Pose, energies: pyrosetta.rosetta.utility.vector1_float) None

C++: core::scoring::ScoreFunction::evaluate_rotamer_intrares_energies(const class core::conformation::RotamerSetBase &, const class core::pose::Pose &, class utility::vector1<float, class std::allocator<float> > &) const –> void

evaluate_rotamer_intrares_energy_maps(self: pyrosetta.rosetta.core.scoring.ScoreFunction, set: pyrosetta.rosetta.core.conformation.RotamerSetBase, pose: pyrosetta.rosetta.core.pose.Pose, emaps: pyrosetta.rosetta.utility.vector1_core_scoring_EMapVector) None

C++: core::scoring::ScoreFunction::evaluate_rotamer_intrares_energy_maps(const class core::conformation::RotamerSetBase &, const class core::pose::Pose &, class utility::vector1<class core::scoring::EMapVector, class std::allocator<class core::scoring::EMapVector> > &) const –> void

evaluate_rotamer_pair_energies(self: pyrosetta.rosetta.core.scoring.ScoreFunction, set1: pyrosetta.rosetta.core.conformation.RotamerSetBase, set2: pyrosetta.rosetta.core.conformation.RotamerSetBase, pose: pyrosetta.rosetta.core.pose.Pose, energy_table: pyrosetta.rosetta.ObjexxFCL.FArray2D_float_t) None

C++: core::scoring::ScoreFunction::evaluate_rotamer_pair_energies(const class core::conformation::RotamerSetBase &, const class core::conformation::RotamerSetBase &, const class core::pose::Pose &, class ObjexxFCL::FArray2D<float> &) const –> void

static extract_weights_from_file(*args, **kwargs)

Overloaded function.

  1. extract_weights_from_file(filename: str) -> pyrosetta.rosetta.core.scoring.EMapVector

  2. extract_weights_from_file(filename: str, patch: bool) -> pyrosetta.rosetta.core.scoring.EMapVector

C++: core::scoring::ScoreFunction::extract_weights_from_file(const std::string &, bool) –> class core::scoring::EMapVector

static extract_weights_from_stream(*args, **kwargs)

Overloaded function.

  1. extract_weights_from_stream(data: pyrosetta.rosetta.std.istream) -> pyrosetta.rosetta.core.scoring.EMapVector

  2. extract_weights_from_stream(data: pyrosetta.rosetta.std.istream, patch: bool) -> pyrosetta.rosetta.core.scoring.EMapVector

  3. extract_weights_from_stream(data: pyrosetta.rosetta.std.istream, patch: bool, filename: str) -> pyrosetta.rosetta.core.scoring.EMapVector

C++: core::scoring::ScoreFunction::extract_weights_from_stream(std::istream &, bool, const std::string &) –> class core::scoring::EMapVector

finalize_after_derivatives(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::ScoreFunction::finalize_after_derivatives(class core::pose::Pose &) const –> void

finalize_after_minimizing(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) None

Called after minimization.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::ScoreFunction::finalize_after_minimizing(class core::pose::Pose &) const –> void

get_name(self: pyrosetta.rosetta.core.scoring.ScoreFunction) str

C++: core::scoring::ScoreFunction::get_name() const –> std::string

get_nonzero_weighted_scoretypes(self: pyrosetta.rosetta.core.scoring.ScoreFunction) pyrosetta.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

C++: core::scoring::ScoreFunction::get_nonzero_weighted_scoretypes() const –> const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &

get_self_ptr(self: pyrosetta.rosetta.core.scoring.ScoreFunction) pyrosetta.rosetta.core.scoring.ScoreFunction

C++: core::scoring::ScoreFunction::get_self_ptr() –> class std::shared_ptr<class core::scoring::ScoreFunction>

get_sub_score(*args, **kwargs)

Overloaded function.

  1. get_sub_score(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, residue_mask: pyrosetta.rosetta.utility.vector1_bool) -> float

Compute the score for subset of residues

C++: core::scoring::ScoreFunction::get_sub_score(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &) const –> double

  1. get_sub_score(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, residue_mask: pyrosetta.rosetta.utility.vector1_bool, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

Compute the score for subset of residues

C++: core::scoring::ScoreFunction::get_sub_score(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, class core::scoring::EMapVector &) const –> void

  1. get_sub_score(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, residue_mask: pyrosetta.rosetta.utility.vector1_bool) -> float

Compute the score for subset of residues

C++: core::scoring::ScoreFunction::get_sub_score(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &) const –> double

  1. get_sub_score(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, residue_mask: pyrosetta.rosetta.utility.vector1_bool, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

Compute the score for subset of residues

C++: core::scoring::ScoreFunction::get_sub_score(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, class core::scoring::EMapVector &) const –> void

get_sub_score_exclude_res(*args, **kwargs)

Overloaded function.

  1. get_sub_score_exclude_res(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, exclude_list: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

Compute the score for subset of residues

C++: core::scoring::ScoreFunction::get_sub_score_exclude_res(const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> double

  1. get_sub_score_exclude_res(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, exclude_list: pyrosetta.rosetta.utility.vector1_unsigned_long, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

Compute the score for subset of residues

C++: core::scoring::ScoreFunction::get_sub_score_exclude_res(const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class core::scoring::EMapVector &) const –> void

  1. get_sub_score_exclude_res(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, exclude_list: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

Compute the score for subset of residues

C++: core::scoring::ScoreFunction::get_sub_score_exclude_res(class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> double

  1. get_sub_score_exclude_res(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, exclude_list: pyrosetta.rosetta.utility.vector1_unsigned_long, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

Compute the score for subset of residues

C++: core::scoring::ScoreFunction::get_sub_score_exclude_res(class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class core::scoring::EMapVector &) const –> void

get_weight(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.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

C++: core::scoring::ScoreFunction::get_weight(const enum core::scoring::ScoreType &) const –> double

has_nonzero_weight(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.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

C++: core::scoring::ScoreFunction::has_nonzero_weight(const enum core::scoring::ScoreType &) const –> bool

has_zero_weight(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.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

C++: core::scoring::ScoreFunction::has_zero_weight(const enum core::scoring::ScoreType &) const –> bool

indicate_required_context_graphs(self: pyrosetta.rosetta.core.scoring.ScoreFunction, context_graphs_required: pyrosetta.rosetta.utility.vector1_bool) None

find which context graphs the energy methods require

C++: core::scoring::ScoreFunction::indicate_required_context_graphs(class utility::vector1<bool, class std::allocator<bool> > &) const –> void

info(self: pyrosetta.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 )

C++: core::scoring::ScoreFunction::info() const –> class std::shared_ptr<class core::scoring::ScoreFunctionInfo>

initialize_from_file(self: pyrosetta.rosetta.core.scoring.ScoreFunction, filename: str) None

Resets everything before reading the <filename>

C++: core::scoring::ScoreFunction::initialize_from_file(const std::string &) –> void

long_range_energies_begin(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::long_range_energies_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy> > > >

long_range_energies_end(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::long_range_energies_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy> > > >

max_atomic_interaction_cutoff(self: pyrosetta.rosetta.core.scoring.ScoreFunction) float
Returns the largest atomic interaction cutoff required by the

EnergyMethods

C++: core::scoring::ScoreFunction::max_atomic_interaction_cutoff() const –> double

merge(self: pyrosetta.rosetta.core.scoring.ScoreFunction, scorefxn_to_be_merged: pyrosetta.rosetta.core.scoring.ScoreFunction) None

Merges in the weights of another score function

example(s):

scorefxn.merge(scorefxn2)

See also:

ScoreFunction ScoreFunction.weights Energies create_score_function

C++: core::scoring::ScoreFunction::merge(const class core::scoring::ScoreFunction &) –> void

name(self: pyrosetta.rosetta.core.scoring.ScoreFunction, weights_tag: str) None
Accumulates the unweighted one body energies of all context

independent one body energies for <pose> Residue <rsd> into EnergyMap <emap>

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::name(const std::string &) –> void

perturb_weights(self: pyrosetta.rosetta.core.scoring.ScoreFunction) None

Randomly perturbs non-zero score function weights

C++: core::scoring::ScoreFunction::perturb_weights() –> void

pre_scoring(self: pyrosetta.rosetta.protocols.flexpack.OtherContextScoreFunction) None

C++: protocols::flexpack::OtherContextScoreFunction::pre_scoring() –> void

prepare_rotamers_for_packing(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, set: pyrosetta.rosetta.core.conformation.RotamerSetBase) None
Lets the scoring functions cache anything they need to rapidly

calculate rotamer pair energies used in packing (like a trie, e.g.)

C++: core::scoring::ScoreFunction::prepare_rotamers_for_packing(const class core::pose::Pose &, class core::conformation::RotamerSetBase &) const –> void

provide_citation_info(self: pyrosetta.rosetta.core.scoring.ScoreFunction, citations: pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) None
Provide citations to the passed CitationCollectionList

This allows the scorefunciton to provide citaitons for itself itself and for any modules that it invokes (particularl energy methods).

The default implementation of this provides a vector of citations from all energy methods that

C++: core::scoring::ScoreFunction::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

ready_for_nonideal_scoring(self: pyrosetta.rosetta.core.scoring.ScoreFunction) bool

C++: core::scoring::ScoreFunction::ready_for_nonideal_scoring() const –> bool

reinitialize_minnode_for_residue(self: pyrosetta.rosetta.core.scoring.ScoreFunction, min_node: core::scoring::MinimizationNode, rsd: pyrosetta.rosetta.core.conformation.Residue, res_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache, min_map: core::kinematics::MinimizerMapBase, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::ScoreFunction::reinitialize_minnode_for_residue(class core::scoring::MinimizationNode &, const class core::conformation::Residue &, class basic::datacache::BasicDataCache &, const class core::kinematics::MinimizerMapBase &, class core::pose::Pose &) const –> void

reset(*args, **kwargs)

Overloaded function.

  1. reset(self: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

Resets the ScoreFunction to default values, reading from the global options collection

C++: core::scoring::ScoreFunction::reset() –> void

  1. reset(self: pyrosetta.rosetta.core.scoring.ScoreFunction, options: pyrosetta.rosetta.utility.options.OptionCollection) -> None

Resets the ScoreFunction to default values, reading from a (possibly local) options collection

C++: core::scoring::ScoreFunction::reset(const class utility::options::OptionCollection &) –> void

reset_energy_methods(self: pyrosetta.rosetta.core.scoring.ScoreFunction) None

C++: core::scoring::ScoreFunction::reset_energy_methods() –> void

score(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.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.

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

score_by_scoretype(*args, **kwargs)

Overloaded function.

  1. score_by_scoretype(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, t: pyrosetta.rosetta.core.scoring.ScoreType) -> float

  2. score_by_scoretype(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, t: pyrosetta.rosetta.core.scoring.ScoreType, weighted: bool) -> float

Returns the score of the ScoreType <t>

C++: core::scoring::ScoreFunction::score_by_scoretype(class core::pose::Pose &, const enum core::scoring::ScoreType, const bool) const –> double

score_types_by_method_type(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.rosetta.core.scoring.methods.EnergyMethodType) pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

C++: core::scoring::ScoreFunction::score_types_by_method_type(const enum core::scoring::methods::EnergyMethodType &) const –> const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &

serialize_weights(self: pyrosetta.rosetta.core.scoring.ScoreFunction) str
Serializes the non-zero score function term weights

Format: { term : weight, … }

C++: core::scoring::ScoreFunction::serialize_weights() const –> std::string

set_context_pose(self: pyrosetta.rosetta.protocols.flexpack.OtherContextScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: protocols::flexpack::OtherContextScoreFunction::set_context_pose(const class core::pose::Pose &) –> void

set_energy_method_options(self: pyrosetta.rosetta.core.scoring.ScoreFunction, energy_method_options_in: pyrosetta.rosetta.core.scoring.methods.EnergyMethodOptions) None
Sets the EnergyMethodOptions object contained in this ScoreFunction.

with appropriate update of all the energy methods.

C++: core::scoring::ScoreFunction::set_energy_method_options(const class core::scoring::methods::EnergyMethodOptions &) –> void

set_etable(self: pyrosetta.rosetta.core.scoring.ScoreFunction, etable_name: str) None
Given a <filename> (represented by a std::string), set the

e_table for this ScoreFunction.

C++: core::scoring::ScoreFunction::set_etable(const std::string &) –> void

set_method_weights(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.rosetta.core.scoring.ScoreType, wts: pyrosetta.rosetta.utility.vector1_double) None

C++: core::scoring::ScoreFunction::set_method_weights(const enum core::scoring::ScoreType &, const class utility::vector1<double, class std::allocator<double> > &) –> void

set_weight(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.rosetta.core.scoring.ScoreType, setting: float) None

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

C++: core::scoring::ScoreFunction::set_weight(const enum core::scoring::ScoreType &, const double) –> void

set_weight_if_zero(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.rosetta.core.scoring.ScoreType, setting: float) None

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

C++: core::scoring::ScoreFunction::set_weight_if_zero(const enum core::scoring::ScoreType &, const double) –> void

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) None

C++: core::scoring::ScoreFunction::setup_for_derivatives(class core::pose::Pose &) const –> void

setup_for_lr2benmeth_minimization_for_respair(*args, **kwargs)

Overloaded function.

  1. setup_for_lr2benmeth_minimization_for_respair(self: pyrosetta.rosetta.core.scoring.ScoreFunction, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, lr2benergy: pyrosetta.rosetta.core.scoring.methods.LongRangeTwoBodyEnergy, g: core::scoring::MinimizationGraph, min_map: core::kinematics::MinimizerMapBase, p: pyrosetta.rosetta.core.pose.Pose, res_moving_wrt_eachother: bool, accumulate_fixed_energies: bool, rni: core::scoring::ResidueNeighborConstIterator, fixed_energies: pyrosetta.rosetta.core.scoring.EMapVector) -> None

  2. setup_for_lr2benmeth_minimization_for_respair(self: pyrosetta.rosetta.core.scoring.ScoreFunction, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, lr2benergy: pyrosetta.rosetta.core.scoring.methods.LongRangeTwoBodyEnergy, g: core::scoring::MinimizationGraph, min_map: core::kinematics::MinimizerMapBase, p: pyrosetta.rosetta.core.pose.Pose, res_moving_wrt_eachother: bool, accumulate_fixed_energies: bool, rni: core::scoring::ResidueNeighborConstIterator, fixed_energies: pyrosetta.rosetta.core.scoring.EMapVector, edge_weight: float) -> None

  3. setup_for_lr2benmeth_minimization_for_respair(self: pyrosetta.rosetta.core.scoring.ScoreFunction, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, lr2benergy: pyrosetta.rosetta.core.scoring.methods.LongRangeTwoBodyEnergy, g: core::scoring::MinimizationGraph, min_map: core::kinematics::MinimizerMapBase, p: pyrosetta.rosetta.core.pose.Pose, res_moving_wrt_eachother: bool, accumulate_fixed_energies: bool, rni: core::scoring::ResidueNeighborConstIterator, fixed_energies: pyrosetta.rosetta.core.scoring.EMapVector, edge_weight: float, edge_dweight: float) -> None

Initialize an edge in the MinimizationGraph with a particular long-range two body

C++: core::scoring::ScoreFunction::setup_for_lr2benmeth_minimization_for_respair(const class core::conformation::Residue &, const class core::conformation::Residue &, class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy>, class core::scoring::MinimizationGraph &, const class core::kinematics::MinimizerMapBase &, class core::pose::Pose &, const bool, bool, class std::shared_ptr<class core::scoring::ResidueNeighborConstIterator>, class core::scoring::EMapVector &, const double, const double) const –> void

setup_for_minimizing(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, min_map: core::kinematics::MinimizerMapBase) None
Initializes a MinimizationGraph and caches it in

Energies object of <pose>

: for use during minimization

C++: core::scoring::ScoreFunction::setup_for_minimizing(class core::pose::Pose &, const class core::kinematics::MinimizerMapBase &) const –> void

setup_for_minimizing_for_node(self: pyrosetta.rosetta.core.scoring.ScoreFunction, min_node: core::scoring::MinimizationNode, rsd: pyrosetta.rosetta.core.conformation.Residue, res_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache, min_map: core::kinematics::MinimizerMapBase, pose: pyrosetta.rosetta.core.pose.Pose, accumulate_fixed_energies: bool, fixed_energies: pyrosetta.rosetta.core.scoring.EMapVector) None
Initialize a single node of a MinimizationGraph with the one-body and two-body

energy methods that are held within this ScoreFunction object.

C++: core::scoring::ScoreFunction::setup_for_minimizing_for_node(class core::scoring::MinimizationNode &, const class core::conformation::Residue &, class basic::datacache::BasicDataCache &, const class core::kinematics::MinimizerMapBase &, class core::pose::Pose &, bool, class core::scoring::EMapVector &) const –> void

setup_for_minimizing_sr2b_enmeths_for_minedge(*args, **kwargs)

Overloaded function.

  1. setup_for_minimizing_sr2b_enmeths_for_minedge(self: pyrosetta.rosetta.core.scoring.ScoreFunction, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, min_edge: core::scoring::MinimizationEdge, min_map: core::kinematics::MinimizerMapBase, pose: pyrosetta.rosetta.core.pose.Pose, res_moving_wrt_eachother: bool, accumulate_fixed_energies: bool, energy_edge: core::scoring::EnergyEdge, fixed_energies: pyrosetta.rosetta.core.scoring.EMapVector) -> None

  2. setup_for_minimizing_sr2b_enmeths_for_minedge(self: pyrosetta.rosetta.core.scoring.ScoreFunction, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, min_edge: core::scoring::MinimizationEdge, min_map: core::kinematics::MinimizerMapBase, pose: pyrosetta.rosetta.core.pose.Pose, res_moving_wrt_eachother: bool, accumulate_fixed_energies: bool, energy_edge: core::scoring::EnergyEdge, fixed_energies: pyrosetta.rosetta.core.scoring.EMapVector, edge_weight: float) -> None

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

C++: core::scoring::ScoreFunction::setup_for_minimizing_sr2b_enmeths_for_minedge(const class core::conformation::Residue &, const class core::conformation::Residue &, class core::scoring::MinimizationEdge &, const class core::kinematics::MinimizerMapBase &, class core::pose::Pose &, const bool, bool, const class core::scoring::EnergyEdge *, class core::scoring::EMapVector &, const double) const –> void

setup_for_packing(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, residues_repacking: pyrosetta.rosetta.utility.vector1_bool, residues_designing: pyrosetta.rosetta.utility.vector1_bool) None
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

C++: core::scoring::ScoreFunction::setup_for_packing(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, const class utility::vector1<bool, class std::allocator<bool> > &) const –> void

setup_for_packing_with_rotsets(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, rotsets: core::pack_basic::RotamerSetsBase) None
Lets the scoring functions cache anything they need to calculate

energies in a packing step (pack_rotamers) in the context of all available rotamers

The exact order of events when setting up for packing are as follows:
  1. setup_for_packing() is called for all energy methods

  2. rotamers are built

  3. setup_for_packing_with_rotsets() is called for all energy methods

  4. prepare_rotamers_for_packing() is called for all energy methods

  5. The energy methods are asked to score all rotamers and rotamer pairs

  6. Annealing begins

The pose is specifically non-const here so that energy methods can store data in it

: Used in ApproximateBuriedUnsatPenalty to pre-compute compatible rotamers

C++: core::scoring::ScoreFunction::setup_for_packing_with_rotsets(class core::pose::Pose &, const class std::shared_ptr<class core::pack_basic::RotamerSetsBase> &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) None
For external scorers: Let the energy methods prepare for

evaluating their scores on a particular structure

: invoked during scoring.

C++: core::scoring::ScoreFunction::setup_for_scoring(class core::pose::Pose &) const –> void

show(*args, **kwargs)

Overloaded function.

  1. show(self: pyrosetta.rosetta.core.scoring.ScoreFunction, out: pyrosetta.rosetta.std.ostream) -> None

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

  1. show(self: pyrosetta.rosetta.core.scoring.ScoreFunction, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Scores <pose> and shows the raw and weighted scores for each

non-zero ScoreType

example(s):

scorefxn.show(pose)

See also:

ScoreFunction ScoreFunction.weights Energies create_score_function

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

  1. show(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) -> None

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

C++: core::scoring::ScoreFunction::show(class core::pose::Pose &) const –> void

show_additional(*args, **kwargs)

Overloaded function.

  1. show_additional(self: pyrosetta.rosetta.core.scoring.ScoreFunction, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) -> None

  2. show_additional(self: pyrosetta.rosetta.core.scoring.ScoreFunction, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose: bool) -> None

C++: core::scoring::ScoreFunction::show_additional(std::ostream &, class core::pose::Pose &, bool) const –> void

show_line(self: pyrosetta.rosetta.core.scoring.ScoreFunction, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) None

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

show_line_headers(self: pyrosetta.rosetta.core.scoring.ScoreFunction, out: pyrosetta.rosetta.std.ostream) None

C++: core::scoring::ScoreFunction::show_line_headers(std::ostream &) const –> void

show_pretty(self: pyrosetta.rosetta.core.scoring.ScoreFunction, out: pyrosetta.rosetta.std.ostream) None

similar output as show( ostream, pose ) but without the pose

C++: core::scoring::ScoreFunction::show_pretty(std::ostream &) const –> void

update_residue_for_packing(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, resid: int) None
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.

C++: core::scoring::ScoreFunction::update_residue_for_packing(class core::pose::Pose &, unsigned long) const –> void

weighted_sum(self: pyrosetta.rosetta.core.scoring.ScoreFunction, unweighted: pyrosetta.rosetta.core.scoring.EMapVector) float

Returns the weighted sum of the given energy map, given the current set of weights

example(s):

scorefxn.weighted_sum(scores_emap)

See also:

ScoreFunction ScoreFunction.get_weight ScoreFunction.set_weight ScoreFunction.weights

C++: core::scoring::ScoreFunction::weighted_sum(const class core::scoring::EMapVector &) const –> double

weights(self: pyrosetta.rosetta.core.scoring.ScoreFunction) pyrosetta.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

C++: core::scoring::ScoreFunction::weights() const –> const class core::scoring::EMapVector &

whole_structure_types(self: pyrosetta.rosetta.core.scoring.ScoreFunction) pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

C++: core::scoring::ScoreFunction::whole_structure_types() const –> const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &

ws_methods_begin(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::ws_methods_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::WholeStructureEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::WholeStructureEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::WholeStructureEnergy> > > >

ws_methods_end(self: pyrosetta.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> > > >

C++: core::scoring::ScoreFunction::ws_methods_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::WholeStructureEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::WholeStructureEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::WholeStructureEnergy> > > >