simple_metrics¶

Bindings for protocols::analysis::simple_metrics namespace

class pyrosetta.rosetta.protocols.analysis.simple_metrics.CompositeEnergyMetric¶

Bases: pyrosetta.rosetta.core.simple_metrics.CompositeRealMetric

A metric to report/calculate all of the energies of a scorefunction that are not 0 or the delta of each energy between another input pose or the set native.

apply(*args, **kwargs)¶

Overloaded function.

apply(self: pyrosetta.rosetta.core.simple_metrics.CompositeRealMetric, pose: pyrosetta.rosetta.core.pose.Pose) -> None
apply(self: pyrosetta.rosetta.core.simple_metrics.CompositeRealMetric, pose: pyrosetta.rosetta.core.pose.Pose, prefix: str) -> None
apply(self: pyrosetta.rosetta.core.simple_metrics.CompositeRealMetric, pose: pyrosetta.rosetta.core.pose.Pose, prefix: str, suffix: str) -> None

Calculate the metric and add it to the pose as a score.

labeled as prefix+calc_name+”_”+metric+suffix. calc_name is the individual component of the composite values calculated here

Score is added through setPoseExtraScore and is output: into the score table/ score file at pose output.

C++: core::simple_metrics::CompositeRealMetric::apply(class core::pose::Pose &, class std::basic_string<char>, class std::basic_string<char>) const –> void

assign(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.CompositeEnergyMetric, : pyrosetta.rosetta.protocols.analysis.simple_metrics.CompositeEnergyMetric) → pyrosetta.rosetta.protocols.analysis.simple_metrics.CompositeEnergyMetric¶: C++: protocols::analysis::simple_metrics::CompositeEnergyMetric::operator=(const class protocols::analysis::simple_metrics::CompositeEnergyMetric &) –> class protocols::analysis::simple_metrics::CompositeEnergyMetric &

calculate(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.CompositeEnergyMetric, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.map_std_string_double¶

Calculate the metric.

C++: protocols::analysis::simple_metrics::CompositeEnergyMetric::calculate(const class core::pose::Pose &) const –> class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >

clone(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.CompositeEnergyMetric) → pyrosetta.rosetta.core.simple_metrics.SimpleMetric¶: C++: protocols::analysis::simple_metrics::CompositeEnergyMetric::clone() const –> class std::shared_ptr<class core::simple_metrics::SimpleMetric>

get_metric_names(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.CompositeEnergyMetric) → pyrosetta.rosetta.utility.vector1_std_string¶

Get the metric name(s) that this Metric will calculate

C++: protocols::analysis::simple_metrics::CompositeEnergyMetric::get_metric_names() const –> class utility::vector1<std::string, class std::allocator<std::string > >

load_native_pose_as_reference(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.CompositeEnergyMetric) → None¶

Load any set in:file:native as the reference pose.: This is opt-in to save on loading time.

C++: protocols::analysis::simple_metrics::CompositeEnergyMetric::load_native_pose_as_reference() –> void

metric(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.CompositeEnergyMetric) → str¶

Name of the metric

C++: protocols::analysis::simple_metrics::CompositeEnergyMetric::metric() const –> std::string

name(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.CompositeEnergyMetric) → str¶

Name of the class

C++: protocols::analysis::simple_metrics::CompositeEnergyMetric::name() const –> std::string

name_static() → str¶

Name of the class for creator.

C++: protocols::analysis::simple_metrics::CompositeEnergyMetric::name_static() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.CompositeEnergyMetric, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

called by parse_my_tag – should not be used directly

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

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::analysis::simple_metrics::CompositeEnergyMetric::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_comparison_pose(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.CompositeEnergyMetric, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Set a pose into to calculate/report delta of total energy.: (apply_pose - comparison_pose)

C++: protocols::analysis::simple_metrics::CompositeEnergyMetric::set_comparison_pose(const class core::pose::Pose &) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.CompositeEnergyMetric, residue_selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶

Set a residue selector to each energy term for the subset of residues.

C++: protocols::analysis::simple_metrics::CompositeEnergyMetric::set_residue_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_scorefunction(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.CompositeEnergyMetric, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Set a scorefunction. Will use default Rosetta scorefunction if not set.

C++: protocols::analysis::simple_metrics::CompositeEnergyMetric::set_scorefunction(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

type(self: pyrosetta.rosetta.core.simple_metrics.SimpleMetric) → str¶: C++: core::simple_metrics::SimpleMetric::type() const –> std::string

class pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric¶

Bases: pyrosetta.rosetta.core.simple_metrics.RealMetric

A metric to calculate the dihedral distance between two poses or the input and the set cmd-line native. Can set a subset of residues to calculate via ResidueSelector.

This is the normalized metric in degrees

Metric described in:: North B, Lehmann A, Dunbrack RL. A new clustering of antibody CDR loop conformations. J Mol Biol 2011; 406:228-256.
NOTE: Only works for Protein and Carbohydrate residues as dihedral definitions in Rosetta are still aweful.: Metric is computed on the protein and carbohydrate backbone.

apply(*args, **kwargs)¶

Overloaded function.

apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose) -> None
apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose, prefix: str) -> None
apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose, prefix: str, suffix: str) -> None

Calculate the metric and add it to the pose as a score.

labeled as prefix+metric+suffix.

Score is added through setPoseExtraScore and is output: into the score table/ score file at pose output.

C++: core::simple_metrics::RealMetric::apply(class core::pose::Pose &, class std::basic_string<char>, class std::basic_string<char>) const –> void

assign(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric, : pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric) → pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric¶: C++: protocols::analysis::simple_metrics::DihedralDistanceMetric::operator=(const class protocols::analysis::simple_metrics::DihedralDistanceMetric &) –> class protocols::analysis::simple_metrics::DihedralDistanceMetric &

calculate(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric, pose: pyrosetta.rosetta.core.pose.Pose) → float¶

Calculate DihedralDistance metric.: This is the normalized metric in degrees

Metric described in:

North B, Lehmann A, Dunbrack RL. A new clustering of antibody CDR loop conformations. J Mol Biol 2011; 406:228-256.

C++: protocols::analysis::simple_metrics::DihedralDistanceMetric::calculate(const class core::pose::Pose &) const –> double

clone(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric) → pyrosetta.rosetta.core.simple_metrics.SimpleMetric¶: C++: protocols::analysis::simple_metrics::DihedralDistanceMetric::clone() const –> class std::shared_ptr<class core::simple_metrics::SimpleMetric>

get_metric_names(self: pyrosetta.rosetta.core.simple_metrics.RealMetric) → pyrosetta.rosetta.utility.vector1_std_string¶

Get the metric name(s) that this Metric will calculate

C++: core::simple_metrics::RealMetric::get_metric_names() const –> class utility::vector1<std::string, class std::allocator<std::string > >

load_native_pose_as_reference(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric) → None¶

Load any set in:file:native as the reference pose.: This is opt-in to save on loading time.

C++: protocols::analysis::simple_metrics::DihedralDistanceMetric::load_native_pose_as_reference() –> void

metric(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric) → str¶

Name of the metric

C++: protocols::analysis::simple_metrics::DihedralDistanceMetric::metric() const –> std::string

name(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric) → str¶

Name of the class

C++: protocols::analysis::simple_metrics::DihedralDistanceMetric::name() const –> std::string

name_static() → str¶

Name of the class for creator.

C++: protocols::analysis::simple_metrics::DihedralDistanceMetric::name_static() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

called by parse_my_tag – should not be used directly

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

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::analysis::simple_metrics::DihedralDistanceMetric::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_comparison_pose(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Set a reference pose to calculate rmsd

C++: protocols::analysis::simple_metrics::DihedralDistanceMetric::set_comparison_pose(const class core::pose::Pose &) –> void

set_include_protein_omega(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric, include_omega: bool) → None¶

Set the boolean to include protein omega.: Default false.

C++: protocols::analysis::simple_metrics::DihedralDistanceMetric::set_include_protein_omega(bool) –> void

set_residue_mapping(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric, res_map: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long) → None¶

Set a map to compute the Dihedral distance on input->reference residue numbers.

C++: protocols::analysis::simple_metrics::DihedralDistanceMetric::set_residue_mapping(const class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric, residue_selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶

Set a residue selector to calculate total energy of a subset of residues.

C++: protocols::analysis::simple_metrics::DihedralDistanceMetric::set_residue_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_residue_selector_reference(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.DihedralDistanceMetric, residue_selector_ref: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶

Set a residue selector for the comparison pose.

C++: protocols::analysis::simple_metrics::DihedralDistanceMetric::set_residue_selector_reference(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

type(self: pyrosetta.rosetta.core.simple_metrics.SimpleMetric) → str¶: C++: core::simple_metrics::SimpleMetric::type() const –> std::string

class pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric¶

Bases: pyrosetta.rosetta.core.simple_metrics.RealMetric

A metric to calculate the RMSD between two poses or the input and the set cmd-line native. Can set a subset of residues to calculate via ResidueSelector.

Default is all_heavy

We match all corresponding atoms and do not fail if a residue does not match up.

apply(*args, **kwargs)¶

Overloaded function.

apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose) -> None
apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose, prefix: str) -> None
apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose, prefix: str, suffix: str) -> None

Calculate the metric and add it to the pose as a score.

labeled as prefix+metric+suffix.

Score is added through setPoseExtraScore and is output: into the score table/ score file at pose output.

C++: core::simple_metrics::RealMetric::apply(class core::pose::Pose &, class std::basic_string<char>, class std::basic_string<char>) const –> void

assign(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric, : pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric) → pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric¶: C++: protocols::analysis::simple_metrics::RMSDMetric::operator=(const class protocols::analysis::simple_metrics::RMSDMetric &) –> class protocols::analysis::simple_metrics::RMSDMetric &

calculate(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric, pose: pyrosetta.rosetta.core.pose.Pose) → float¶

Calculate the metric. This is the RMSD between the input and the set comparison pose.

If native is set on the cmd-line, we will use that. Deafult is to calculate all_heavy atoms - but this can be set.

Make sure that reference pose and set pose are the same length or set a map to compare specific residues.: We match all corresponding atoms for each residue to match.

C++: protocols::analysis::simple_metrics::RMSDMetric::calculate(const class core::pose::Pose &) const –> double

clone(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric) → pyrosetta.rosetta.core.simple_metrics.SimpleMetric¶: C++: protocols::analysis::simple_metrics::RMSDMetric::clone() const –> class std::shared_ptr<class core::simple_metrics::SimpleMetric>

get_metric_names(self: pyrosetta.rosetta.core.simple_metrics.RealMetric) → pyrosetta.rosetta.utility.vector1_std_string¶

Get the metric name(s) that this Metric will calculate

C++: core::simple_metrics::RealMetric::get_metric_names() const –> class utility::vector1<std::string, class std::allocator<std::string > >

load_native_pose_as_reference(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric) → None¶

Load any set in:file:native as the reference pose.: This is opt-in to save on loading time.

C++: protocols::analysis::simple_metrics::RMSDMetric::load_native_pose_as_reference() –> void

metric(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric) → str¶

Name of the metric

C++: protocols::analysis::simple_metrics::RMSDMetric::metric() const –> std::string

name(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric) → str¶

Name of the class

C++: protocols::analysis::simple_metrics::RMSDMetric::name() const –> std::string

name_static() → str¶

Name of the class for creator.

C++: protocols::analysis::simple_metrics::RMSDMetric::name_static() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

called by parse_my_tag – should not be used directly

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

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::analysis::simple_metrics::RMSDMetric::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_comparison_pose(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Set a reference pose to calculate rmsd

C++: protocols::analysis::simple_metrics::RMSDMetric::set_comparison_pose(const class core::pose::Pose &) –> void

set_corresponding_atoms_robust(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric, robust: bool) → None¶

Set this to false to fail instead.

C++: protocols::analysis::simple_metrics::RMSDMetric::set_corresponding_atoms_robust(bool) –> void

set_residue_mapping(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric, rmsd_map: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long) → None¶

Set a map to compute the RMSD on input->reference residue numbers.

C++: protocols::analysis::simple_metrics::RMSDMetric::set_residue_mapping(const class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric, residue_selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶

Set a residue selector to calculate total energy of a subset of residues.

C++: protocols::analysis::simple_metrics::RMSDMetric::set_residue_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_residue_selector_reference(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric, residue_selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶

Set a reference residue selector. Both selectors should return the same number of residues.

C++: protocols::analysis::simple_metrics::RMSDMetric::set_residue_selector_reference(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_rmsd_type(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RMSDMetric, rmsd_type: pyrosetta.rosetta.protocols.analysis.simple_metrics.rmsd_atoms) → None¶

Set what we will be calculating the RMSD on.

C++: protocols::analysis::simple_metrics::RMSDMetric::set_rmsd_type(enum protocols::analysis::simple_metrics::rmsd_atoms) –> void

type(self: pyrosetta.rosetta.core.simple_metrics.SimpleMetric) → str¶: C++: core::simple_metrics::SimpleMetric::type() const –> std::string

class pyrosetta.rosetta.protocols.analysis.simple_metrics.RunSimpleMetricsMover¶

Bases: pyrosetta.rosetta.protocols.moves.Mover

Run the set of SimpleMetrics. Add the data to the pose, which will be output int the score file. with the given prefix and suffix. (prefix+metric_name+suffix)

add_simple_metric(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RunSimpleMetricsMover, metric: pyrosetta.rosetta.core.simple_metrics.SimpleMetric) → None¶

Add a simple metric to run.

C++: protocols::analysis::simple_metrics::RunSimpleMetricsMover::add_simple_metric(class std::shared_ptr<const class core::simple_metrics::SimpleMetric>) –> void

apply(*args, **kwargs)¶

Overloaded function.

apply(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RunSimpleMetricsMover, pose: pyrosetta.rosetta.core.pose.Pose, prefix: str, suffix: str) -> None

Run the set of SimpleMetrics. Add the data to the pose, which will be output int the score file.: with the given prefix and suffix. (prefix+metric_name+suffix)

C++: protocols::analysis::simple_metrics::RunSimpleMetricsMover::apply(class core::pose::Pose &, const class std::basic_string<char> &, const class std::basic_string<char> &) –> void

apply(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RunSimpleMetricsMover, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Run the set of SimpleMetrics. Add the data to the Pose, which will be output in the score file.

C++: protocols::analysis::simple_metrics::RunSimpleMetricsMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RunSimpleMetricsMover, : pyrosetta.rosetta.protocols.analysis.simple_metrics.RunSimpleMetricsMover) → pyrosetta.rosetta.protocols.analysis.simple_metrics.RunSimpleMetricsMover¶: C++: protocols::analysis::simple_metrics::RunSimpleMetricsMover::operator=(const class protocols::analysis::simple_metrics::RunSimpleMetricsMover &) –> class protocols::analysis::simple_metrics::RunSimpleMetricsMover &

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.analysis.simple_metrics.RunSimpleMetricsMover) → pyrosetta.rosetta.protocols.moves.Mover¶

required in the context of the parser/scripting scheme

C++: protocols::analysis::simple_metrics::RunSimpleMetricsMover::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.analysis.simple_metrics.RunSimpleMetricsMover) → pyrosetta.rosetta.protocols.moves.Mover¶

required in the context of the parser/scripting scheme

C++: protocols::analysis::simple_metrics::RunSimpleMetricsMover::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.

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.analysis.simple_metrics.RunSimpleMetricsMover) → str¶: C++: protocols::analysis::simple_metrics::RunSimpleMetricsMover::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

mover_name() → str¶: C++: protocols::analysis::simple_metrics::RunSimpleMetricsMover::mover_name() –> std::string

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

parse_my_tag(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RunSimpleMetricsMover, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

parse XML tag (to use this Mover in Rosetta Scripts)

C++: protocols::analysis::simple_metrics::RunSimpleMetricsMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, const class core::pose::Pose &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::analysis::simple_metrics::RunSimpleMetricsMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

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¶

////////////////////////////end Job Distributor interface////////////////////////////////////////

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 class std::basic_string<char> &) –> 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_prefix(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RunSimpleMetricsMover, prefix: str) → None¶: C++: protocols::analysis::simple_metrics::RunSimpleMetricsMover::set_prefix(const class std::basic_string<char> &) –> void

set_simple_metrics(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RunSimpleMetricsMover, metrics: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_simple_metrics_SimpleMetric_t) → None¶: C++: protocols::analysis::simple_metrics::RunSimpleMetricsMover::set_simple_metrics(class utility::vector1<class std::shared_ptr<const class core::simple_metrics::SimpleMetric>, class std::allocator<class std::shared_ptr<const class core::simple_metrics::SimpleMetric> > >) –> void

set_suffix(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.RunSimpleMetricsMover, suffix: str) → None¶: C++: protocols::analysis::simple_metrics::RunSimpleMetricsMover::set_suffix(const class std::basic_string<char> &) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None¶: C++: protocols::moves::Mover::set_type(const class std::basic_string<char> &) –> void

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
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(class std::basic_ostream<char> &) 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.

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

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

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

C++: protocols::moves::Mover::type(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.analysis.simple_metrics.TotalEnergyMetric¶

Bases: pyrosetta.rosetta.core.simple_metrics.RealMetric

A metric to report the total energy of the system or the delta total energy between another input pose or the set native.

apply(*args, **kwargs)¶

Overloaded function.

apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose) -> None
apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose, prefix: str) -> None
apply(self: pyrosetta.rosetta.core.simple_metrics.RealMetric, pose: pyrosetta.rosetta.core.pose.Pose, prefix: str, suffix: str) -> None

Calculate the metric and add it to the pose as a score.

labeled as prefix+metric+suffix.

Score is added through setPoseExtraScore and is output: into the score table/ score file at pose output.

C++: core::simple_metrics::RealMetric::apply(class core::pose::Pose &, class std::basic_string<char>, class std::basic_string<char>) const –> void

assign(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.TotalEnergyMetric, : pyrosetta.rosetta.protocols.analysis.simple_metrics.TotalEnergyMetric) → pyrosetta.rosetta.protocols.analysis.simple_metrics.TotalEnergyMetric¶: C++: protocols::analysis::simple_metrics::TotalEnergyMetric::operator=(const class protocols::analysis::simple_metrics::TotalEnergyMetric &) –> class protocols::analysis::simple_metrics::TotalEnergyMetric &

calculate(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.TotalEnergyMetric, pose: pyrosetta.rosetta.core.pose.Pose) → float¶

Calculate the metric.

Returns the total score from the scorefunction or the total score of each residue in the residue selector.

If the native pose is given on the command line or a comparison pose is given: will calculate the delta between them (pose - comparison_pose).

C++: protocols::analysis::simple_metrics::TotalEnergyMetric::calculate(const class core::pose::Pose &) const –> double

clone(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.TotalEnergyMetric) → pyrosetta.rosetta.core.simple_metrics.SimpleMetric¶: C++: protocols::analysis::simple_metrics::TotalEnergyMetric::clone() const –> class std::shared_ptr<class core::simple_metrics::SimpleMetric>

get_metric_names(self: pyrosetta.rosetta.core.simple_metrics.RealMetric) → pyrosetta.rosetta.utility.vector1_std_string¶

Get the metric name(s) that this Metric will calculate

C++: core::simple_metrics::RealMetric::get_metric_names() const –> class utility::vector1<std::string, class std::allocator<std::string > >

load_native_pose_as_reference(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.TotalEnergyMetric) → None¶

Load any set in:file:native as the reference pose.: This is opt-in to save on loading time.

C++: protocols::analysis::simple_metrics::TotalEnergyMetric::load_native_pose_as_reference() –> void

metric(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.TotalEnergyMetric) → str¶

Name of the metric

C++: protocols::analysis::simple_metrics::TotalEnergyMetric::metric() const –> std::string

name(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.TotalEnergyMetric) → str¶

Name of the class

C++: protocols::analysis::simple_metrics::TotalEnergyMetric::name() const –> std::string

name_static() → str¶

Name of the class for creator.

C++: protocols::analysis::simple_metrics::TotalEnergyMetric::name_static() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.TotalEnergyMetric, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

called by parse_my_tag – should not be used directly

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

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None¶: C++: protocols::analysis::simple_metrics::TotalEnergyMetric::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_comparison_pose(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.TotalEnergyMetric, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Set a pose into to calculate/report delta of total energy.: (apply_pose - comparison_pose)

C++: protocols::analysis::simple_metrics::TotalEnergyMetric::set_comparison_pose(const class core::pose::Pose &) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.TotalEnergyMetric, residue_selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶

Set a residue selector to calculate total energy of a subset of residues.

C++: protocols::analysis::simple_metrics::TotalEnergyMetric::set_residue_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_scorefunction(self: pyrosetta.rosetta.protocols.analysis.simple_metrics.TotalEnergyMetric, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Set a scorefunction. Will use default Rosetta scorefunction if not set.

C++: protocols::analysis::simple_metrics::TotalEnergyMetric::set_scorefunction(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

type(self: pyrosetta.rosetta.core.simple_metrics.SimpleMetric) → str¶: C++: core::simple_metrics::SimpleMetric::type() const –> std::string

pyrosetta.rosetta.protocols.analysis.simple_metrics.get_rmsd_type_name_map() → pyrosetta.rosetta.std.map_std_string_protocols_analysis_simple_metrics_rmsd_atoms¶: C++: protocols::analysis::simple_metrics::get_rmsd_type_name_map() –> class std::map<std::string, enum protocols::analysis::simple_metrics::rmsd_atoms, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, enum protocols::analysis::simple_metrics::rmsd_atoms> > >

pyrosetta.rosetta.protocols.analysis.simple_metrics.get_rmsd_type_names() → pyrosetta.rosetta.utility.vector1_std_string¶: C++: protocols::analysis::simple_metrics::get_rmsd_type_names() –> class utility::vector1<std::string, class std::allocator<std::string > >

class pyrosetta.rosetta.protocols.analysis.simple_metrics.rmsd_atoms¶

Bases: pybind11_builtins.pybind11_object

Members:

rmsd_protein_bb_heavy

rmsd_protein_bb_heavy_including_O

rmsd_protein_bb_ca

rmsd_sc_heavy

rmsd_sc

rmsd_all_heavy

rmsd_all

rmsd_atom_total

pyrosetta.rosetta.protocols.analysis.simple_metrics.setup_rmsd_atom_names() → pyrosetta.rosetta.std.map_protocols_analysis_simple_metrics_rmsd_atoms_utility_vector1_std_string_std_allocator_std_string_t¶: C++: protocols::analysis::simple_metrics::setup_rmsd_atom_names() –> class std::map<enum protocols::analysis::simple_metrics::rmsd_atoms, class utility::vector1<std::string, class std::allocator<std::string > >, struct std::less<enum protocols::analysis::simple_metrics::rmsd_atoms>, class std::allocator<struct std::pair<const enum protocols::analysis::simple_metrics::rmsd_atoms, class utility::vector1<std::string, class std::allocator<std::string > > > > >