simple_filters

Bindings for protocols::simple_filters namespace

class pyrosetta.rosetta.protocols.simple_filters.AtomicContactFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter, pyrosetta.rosetta.protocols.moves.ResId

detects atomic (<4Ang) contacts between any two atoms of two residues

apply(self: pyrosetta.rosetta.protocols.simple_filters.AtomicContactFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool

C++: protocols::simple_filters::AtomicContactFilter::apply(const class core::pose::Pose &) const –> bool

assign(self: pyrosetta.rosetta.protocols.moves.ResId, : pyrosetta.rosetta.protocols.moves.ResId) → pyrosetta.rosetta.protocols.moves.ResId

C++: protocols::moves::ResId::operator=(const class protocols::moves::ResId &) –> class protocols::moves::ResId &

class_name() → str

C++: protocols::simple_filters::AtomicContactFilter::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.AtomicContactFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::AtomicContactFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.simple_filters.AtomicContactFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::AtomicContactFilter::compute(const class core::pose::Pose &) const –> double

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.AtomicContactFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::AtomicContactFilter::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_resid(self: pyrosetta.rosetta.protocols.moves.ResId) → int

C++: protocols::moves::ResId::get_resid() –> unsigned long &

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

modifiable(*args, **kwargs)

Overloaded function.

1. modifiable(self: pyrosetta.rosetta.protocols.moves.ResId) -> bool

should another method be able to modify resid_. This is used by modify_ResId_based_object as a test

C++: protocols::moves::ResId::modifiable() const –> bool

2. modifiable(self: pyrosetta.rosetta.protocols.moves.ResId, u: bool) -> None

C++: protocols::moves::ResId::modifiable(const bool) –> void

name(self: pyrosetta.rosetta.protocols.simple_filters.AtomicContactFilter) → str

C++: protocols::simple_filters::AtomicContactFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.simple_filters.AtomicContactFilter, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap, : pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::AtomicContactFilter::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::simple_filters::AtomicContactFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.simple_filters.AtomicContactFilter, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::AtomicContactFilter::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.simple_filters.AtomicContactFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::AtomicContactFilter::report_sm(const class core::pose::Pose &) const –> double

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_resid(self: pyrosetta.rosetta.protocols.moves.ResId, r: int) → None

C++: protocols::moves::ResId::set_resid(const unsigned long) –> void

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.simple_filters.AtomicDistanceFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter

detects atomic contacts between two atoms of two residues

apply(self: pyrosetta.rosetta.protocols.simple_filters.AtomicDistanceFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool

C++: protocols::simple_filters::AtomicDistanceFilter::apply(const class core::pose::Pose &) const –> bool

class_name() → str

C++: protocols::simple_filters::AtomicDistanceFilter::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.AtomicDistanceFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::AtomicDistanceFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.simple_filters.AtomicDistanceFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::AtomicDistanceFilter::compute(const class core::pose::Pose &) const –> double

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.AtomicDistanceFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::AtomicDistanceFilter::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

name(self: pyrosetta.rosetta.protocols.simple_filters.AtomicDistanceFilter) → str

C++: protocols::simple_filters::AtomicDistanceFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.simple_filters.AtomicDistanceFilter, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap, : pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::AtomicDistanceFilter::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::simple_filters::AtomicDistanceFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.simple_filters.AtomicDistanceFilter, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::AtomicDistanceFilter::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.simple_filters.AtomicDistanceFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::AtomicDistanceFilter::report_sm(const class core::pose::Pose &) const –> double

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.simple_filters.BSAF_mode

Bases: pybind11_builtins.pybind11_object

Members:

BSAF_all_atoms

BSAF_hydrophobic_atoms

BSAF_polar_atoms

BSAF_end_of_list

class pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter

Calculates buried surface area (exposed surface area minus total surface area, on a per-residue basis). Accepts a residue selector to allow buried subsets to be considered.

apply(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool

returns true if the structure passes the filter, false otherwise

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::apply(const class core::pose::Pose &) const –> bool

atom_mode(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter) → pyrosetta.rosetta.protocols.simple_filters.BSAF_mode

Get the atom mode (the subset of atoms to use).

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::atom_mode() const –> enum protocols::simple_filters::BSAF_mode

class_name() → str

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter) → pyrosetta.rosetta.protocols.filters.Filter

required in the context of the parser/scripting scheme

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

cutoff_buried_surface_area(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter) → float

Get the cutoff buried surface area below which (or above which, if filter_out_low_ is false) structures

are discarded.

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::cutoff_buried_surface_area() const –> const double &

filter_out_low(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter) → bool

Get whether structures with less than the cutoff buried area or greater than the cutoff

buried area are discarded.

If true, structures with less than the cutoff buried area are discrded.

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::filter_out_low() const –> bool

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter) → pyrosetta.rosetta.protocols.filters.Filter

required in the context of the parser/scripting scheme

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

name(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter) → str

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter, 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 Filter in Rosetta Scripts)

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::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::simple_filters::BuriedSurfaceAreaFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter, os: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None

allows printing data to a stream

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

required for reporting score values

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::report_sm(const class core::pose::Pose &) const –> double

residue_selector(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector

Gets the residue selector to use to select a subset of residues for which to calculate

buried surface area.

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::residue_selector() const –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

select_only_FAMILYVW(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter) → bool

Get whether only hydrophobic residues and alanine (FAMILYVW) are considered. False by default.

The selection FAMILYVW is combined with the residue selector, if specified, using AND logic.

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::select_only_FAMILYVW() const –> bool

set_atom_mode(*args, **kwargs)

Overloaded function.

1. set_atom_mode(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter, setting: str) -> None

Set the atom mode (the subset of atoms to use for the calculation) by string.

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::set_atom_mode(const class std::basic_string<char> &) –> void

2. set_atom_mode(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter, setting: pyrosetta.rosetta.protocols.simple_filters.BSAF_mode) -> None

Set the atom mode (the subset of atoms to use for the calculation).

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::set_atom_mode(const enum protocols::simple_filters::BSAF_mode) –> void

set_cutoff_buried_surface_area(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter, setting: float) → None

Set the cutoff buried surface area below which (or above which, if filter_out_low_ is false) structures

are discarded.

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::set_cutoff_buried_surface_area(const double &) –> void

set_filter_out_low(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter, setting: bool) → None

Set whether structures with less than the cutoff buried area or greater than the cutoff

buried area are discarded.

If true, structures with less than the cutoff buried area are discrded.

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::set_filter_out_low(const bool) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter, selector_in: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None

Sets the residue selector to use to select a subset of residues for which to calculate

buried surface area.

Copies the input owning pointer; does not clone. This means that residue selectors could be shared with other Rosetta modules.

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::set_residue_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_select_only_FAMILYVW(self: pyrosetta.rosetta.protocols.simple_filters.BuriedSurfaceAreaFilter, setting: bool) → None

Set whether only hydrophobic residues and alanine (FAMILYVW) are considered. False by default.

The selection FAMILYVW is combined with the residue selector, if specified, using AND logic.

C++: protocols::simple_filters::BuriedSurfaceAreaFilter::set_select_only_FAMILYVW(const bool) –> void

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter

filters based on an upper bound # of buried unsatisfied polar residues

apply(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool

C++: protocols::simple_filters::BuriedUnsatHbondFilter::apply(const class core::pose::Pose &) const –> bool

class_name() → str

C++: protocols::simple_filters::BuriedUnsatHbondFilter::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::BuriedUnsatHbondFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::BuriedUnsatHbondFilter::compute(const class core::pose::Pose &) const –> double

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::BuriedUnsatHbondFilter::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

name(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter) → str

C++: protocols::simple_filters::BuriedUnsatHbondFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap, : pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::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::simple_filters::BuriedUnsatHbondFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::BuriedUnsatHbondFilter::report_sm(const class core::pose::Pose &) const –> double

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_burial_cutoff(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, burial_cutoff: float) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_burial_cutoff(double) –> void

set_generous_hbonds_(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, generous_hbonds: bool) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_generous_hbonds_(bool) –> void

set_ignore_bb_heavy_unsats(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, ignore_bb_heavy_unsats: bool) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_ignore_bb_heavy_unsats(bool) –> void

set_ignore_surface_res(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, ignore_surface_res: bool) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_ignore_surface_res(bool) –> void

set_jump_num(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, jump_num: int) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_jump_num(unsigned long) –> void

set_print_out_info_to_pdb(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, print_out_info_to_pdb: bool) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_print_out_info_to_pdb(bool) –> void

set_probe_radius(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, probe_radius: float) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_probe_radius(double) –> void

set_report_all_heavy_atom_unsats(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, report_all_heavy_atom_unsats: bool) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_report_all_heavy_atom_unsats(bool) –> void

set_report_all_unsats(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, report_all_unsats: bool) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_report_all_unsats(bool) –> void

set_report_bb_heavy_atom_unsats(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, report_bb_heavy_atom_unsats: bool) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_report_bb_heavy_atom_unsats(bool) –> void

set_report_nonheavy_unsats(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, report_nonheavy_unsats: bool) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_report_nonheavy_unsats(bool) –> void

set_report_sc_heavy_atom_unsats(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, report_sc_heavy_atom_unsats: bool) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_report_sc_heavy_atom_unsats(bool) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, residue_selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_residue_selector(class std::shared_ptr<class core::select::residue_selector::ResidueSelector>) –> void

set_residue_surface_cutoff(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, residue_surface_cutoff: float) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_residue_surface_cutoff(double) –> void

set_upper_threshold(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, upper_threshold: int) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_upper_threshold(unsigned long) –> void

set_use_ddG_style(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, use_ddG_style: bool) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_use_ddG_style(bool) –> void

set_use_hbnet_behavior(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, use_hbnet_behavior: bool) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_use_hbnet_behavior(bool) –> void

set_use_reporter_behavior(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, use_reporter_behavior: bool) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_use_reporter_behavior(bool) –> void

set_use_sc_neighbors(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, use_sc_neighbors: bool) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_use_sc_neighbors(bool) –> void

set_use_vsasa(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, use_vsasa: bool) → None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::set_use_vsasa(bool) –> void

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

sym_dof_names(*args, **kwargs)

Overloaded function.

1. sym_dof_names(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, sym_dofs: str) -> None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::sym_dof_names(const class std::basic_string<char> &) –> void

2. sym_dof_names(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter) -> str

C++: protocols::simple_filters::BuriedUnsatHbondFilter::sym_dof_names() const –> std::string

task_factory(*args, **kwargs)

Overloaded function.

1. task_factory(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter, tf: pyrosetta.rosetta.core.pack.task.TaskFactory) -> None

C++: protocols::simple_filters::BuriedUnsatHbondFilter::task_factory(class std::shared_ptr<class core::pack::task::TaskFactory>) –> void

2. task_factory(self: pyrosetta.rosetta.protocols.simple_filters.BuriedUnsatHbondFilter) -> pyrosetta.rosetta.core.pack.task.TaskFactory

C++: protocols::simple_filters::BuriedUnsatHbondFilter::task_factory() const –> class std::shared_ptr<class core::pack::task::TaskFactory>

class pyrosetta.rosetta.protocols.simple_filters.CamShiftEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the CamShiftEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.CamShiftEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::CamShiftEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.CamShiftEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.CamShiftEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.CamShiftEvaluatorCreator

C++: protocols::simple_filters::CamShiftEvaluatorCreator::operator=(const class protocols::simple_filters::CamShiftEvaluatorCreator &) –> class protocols::simple_filters::CamShiftEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.CamShiftEvaluatorCreator) → None

C++: protocols::simple_filters::CamShiftEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.CamShiftEvaluatorCreator) → str

C++: protocols::simple_filters::CamShiftEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.simple_filters.ChainBreak

Bases: pyrosetta.rosetta.protocols.filters.Filter

test whether a pose contains a comment that evaluates to a predefined value. This is useful in controlling execution flow in RosettaScripts.

apply(self: pyrosetta.rosetta.protocols.simple_filters.ChainBreak, pose: pyrosetta.rosetta.core.pose.Pose) → bool

C++: protocols::simple_filters::ChainBreak::apply(const class core::pose::Pose &) const –> bool

chain_num(*args, **kwargs)

Overloaded function.

1. chain_num(self: pyrosetta.rosetta.protocols.simple_filters.ChainBreak) -> int

C++: protocols::simple_filters::ChainBreak::chain_num() const –> unsigned long

2. chain_num(self: pyrosetta.rosetta.protocols.simple_filters.ChainBreak, t: int) -> None

C++: protocols::simple_filters::ChainBreak::chain_num(const unsigned long &) –> void

class_name() → str

C++: protocols::simple_filters::ChainBreak::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.ChainBreak) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::ChainBreak::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.simple_filters.ChainBreak, pose: pyrosetta.rosetta.core.pose.Pose) → int

C++: protocols::simple_filters::ChainBreak::compute(const class core::pose::Pose &) const –> unsigned long

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.ChainBreak) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::ChainBreak::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

name(self: pyrosetta.rosetta.protocols.simple_filters.ChainBreak) → str

C++: protocols::simple_filters::ChainBreak::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.simple_filters.ChainBreak, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::ChainBreak::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::simple_filters::ChainBreak::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.simple_filters.ChainBreak, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::ChainBreak::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.simple_filters.ChainBreak, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::ChainBreak::report_sm(const class core::pose::Pose &) const –> double

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

threshold(*args, **kwargs)

Overloaded function.

1. threshold(self: pyrosetta.rosetta.protocols.simple_filters.ChainBreak) -> int

C++: protocols::simple_filters::ChainBreak::threshold() const –> unsigned long

2. threshold(self: pyrosetta.rosetta.protocols.simple_filters.ChainBreak, t: int) -> None

C++: protocols::simple_filters::ChainBreak::threshold(const unsigned long &) –> void

tolerance(*args, **kwargs)

Overloaded function.

1. tolerance(self: pyrosetta.rosetta.protocols.simple_filters.ChainBreak) -> float

C++: protocols::simple_filters::ChainBreak::tolerance() const –> double

2. tolerance(self: pyrosetta.rosetta.protocols.simple_filters.ChainBreak, t: float) -> None

C++: protocols::simple_filters::ChainBreak::tolerance(const double &) –> void

class pyrosetta.rosetta.protocols.simple_filters.ChainCountFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter

detects atomic contacts between two atoms of two residues

apply(self: pyrosetta.rosetta.protocols.simple_filters.ChainCountFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool

C++: protocols::simple_filters::ChainCountFilter::apply(const class core::pose::Pose &) const –> bool

class_name() → str

C++: protocols::simple_filters::ChainCountFilter::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.ChainCountFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::ChainCountFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.simple_filters.ChainCountFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::ChainCountFilter::compute(const class core::pose::Pose &) const –> double

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.ChainCountFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::ChainCountFilter::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

name(self: pyrosetta.rosetta.protocols.simple_filters.ChainCountFilter) → str

C++: protocols::simple_filters::ChainCountFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.simple_filters.ChainCountFilter, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap, : pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::ChainCountFilter::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::simple_filters::ChainCountFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.simple_filters.ChainCountFilter, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::ChainCountFilter::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.simple_filters.ChainCountFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::ChainCountFilter::report_sm(const class core::pose::Pose &) const –> double

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

threshold(*args, **kwargs)

Overloaded function.

1. threshold(self: pyrosetta.rosetta.protocols.simple_filters.ChainCountFilter, threshold: int) -> None

C++: protocols::simple_filters::ChainCountFilter::threshold(unsigned long) –> void

2. threshold(self: pyrosetta.rosetta.protocols.simple_filters.ChainCountFilter) -> int

C++: protocols::simple_filters::ChainCountFilter::threshold() const –> unsigned long

class pyrosetta.rosetta.protocols.simple_filters.ChiWellRmsdEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the ChiWellRmsdEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.ChiWellRmsdEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::ChiWellRmsdEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.ChiWellRmsdEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.ChiWellRmsdEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.ChiWellRmsdEvaluatorCreator

C++: protocols::simple_filters::ChiWellRmsdEvaluatorCreator::operator=(const class protocols::simple_filters::ChiWellRmsdEvaluatorCreator &) –> class protocols::simple_filters::ChiWellRmsdEvaluatorCreator &

type_name(self: pyrosetta.rosetta.protocols.simple_filters.ChiWellRmsdEvaluatorCreator) → str

C++: protocols::simple_filters::ChiWellRmsdEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.simple_filters.ContactMapEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the ContactMapEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.ContactMapEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::ContactMapEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.ContactMapEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.ContactMapEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.ContactMapEvaluatorCreator

C++: protocols::simple_filters::ContactMapEvaluatorCreator::operator=(const class protocols::simple_filters::ContactMapEvaluatorCreator &) –> class protocols::simple_filters::ContactMapEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.ContactMapEvaluatorCreator) → None

C++: protocols::simple_filters::ContactMapEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.ContactMapEvaluatorCreator) → str

C++: protocols::simple_filters::ContactMapEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.simple_filters.EXCN_CalcFailed

Bases: pyrosetta.rosetta.utility.excn.Exception

Super-simple exception to be thrown when the SC calculator fails to compute

add_msg(self: pyrosetta.rosetta.utility.excn.Exception, str: str) → None

C++: utility::excn::Exception::add_msg(const class std::basic_string<char> &) –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.EXCN_CalcFailed, : pyrosetta.rosetta.protocols.simple_filters.EXCN_CalcFailed) → pyrosetta.rosetta.protocols.simple_filters.EXCN_CalcFailed

C++: protocols::simple_filters::EXCN_CalcFailed::operator=(const class protocols::simple_filters::EXCN_CalcFailed &) –> class protocols::simple_filters::EXCN_CalcFailed &

msg(*args, **kwargs)

Overloaded function.

1. msg(self: pyrosetta.rosetta.utility.excn.Exception) -> str

C++: utility::excn::Exception::msg() const –> std::string

2. msg(self: pyrosetta.rosetta.utility.excn.Exception, m: str) -> None

C++: utility::excn::Exception::msg(const class std::basic_string<char> &) –> void

show(self: pyrosetta.rosetta.utility.excn.Exception, : pyrosetta.rosetta.std.ostream) → None

C++: utility::excn::Exception::show(class std::basic_ostream<char> &) const –> void

what(self: pyrosetta.rosetta.std.exception) → str

C++: std::exception::what() const –> const char *

class pyrosetta.rosetta.protocols.simple_filters.EXCN_InitFailed

Bases: pyrosetta.rosetta.utility.excn.Exception

Super-simple exception to be thrown when we can’t initialize the SC calculator

add_msg(self: pyrosetta.rosetta.utility.excn.Exception, str: str) → None

C++: utility::excn::Exception::add_msg(const class std::basic_string<char> &) –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.EXCN_InitFailed, : pyrosetta.rosetta.protocols.simple_filters.EXCN_InitFailed) → pyrosetta.rosetta.protocols.simple_filters.EXCN_InitFailed

C++: protocols::simple_filters::EXCN_InitFailed::operator=(const class protocols::simple_filters::EXCN_InitFailed &) –> class protocols::simple_filters::EXCN_InitFailed &

msg(*args, **kwargs)

Overloaded function.

1. msg(self: pyrosetta.rosetta.utility.excn.Exception) -> str

C++: utility::excn::Exception::msg() const –> std::string

2. msg(self: pyrosetta.rosetta.utility.excn.Exception, m: str) -> None

C++: utility::excn::Exception::msg(const class std::basic_string<char> &) –> void

show(self: pyrosetta.rosetta.utility.excn.Exception, : pyrosetta.rosetta.std.ostream) → None

C++: utility::excn::Exception::show(class std::basic_ostream<char> &) const –> void

what(self: pyrosetta.rosetta.std.exception) → str

C++: std::exception::what() const –> const char *

class pyrosetta.rosetta.protocols.simple_filters.ExtraScoreEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the ExtraScoreEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.ExtraScoreEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::ExtraScoreEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.ExtraScoreEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.ExtraScoreEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.ExtraScoreEvaluatorCreator

C++: protocols::simple_filters::ExtraScoreEvaluatorCreator::operator=(const class protocols::simple_filters::ExtraScoreEvaluatorCreator &) –> class protocols::simple_filters::ExtraScoreEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.ExtraScoreEvaluatorCreator) → None

C++: protocols::simple_filters::ExtraScoreEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.ExtraScoreEvaluatorCreator) → str

C++: protocols::simple_filters::ExtraScoreEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.simple_filters.JScoreEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the JScoreEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.JScoreEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::JScoreEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.JScoreEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.JScoreEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.JScoreEvaluatorCreator

C++: protocols::simple_filters::JScoreEvaluatorCreator::operator=(const class protocols::simple_filters::JScoreEvaluatorCreator &) –> class protocols::simple_filters::JScoreEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.JScoreEvaluatorCreator) → None

C++: protocols::simple_filters::JScoreEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.JScoreEvaluatorCreator) → str

C++: protocols::simple_filters::JScoreEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.simple_filters.JumpNrEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the JumpNrEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.JumpNrEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::JumpNrEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.JumpNrEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.JumpNrEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.JumpNrEvaluatorCreator

C++: protocols::simple_filters::JumpNrEvaluatorCreator::operator=(const class protocols::simple_filters::JumpNrEvaluatorCreator &) –> class protocols::simple_filters::JumpNrEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.JumpNrEvaluatorCreator) → None

C++: protocols::simple_filters::JumpNrEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.JumpNrEvaluatorCreator) → str

C++: protocols::simple_filters::JumpNrEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.simple_filters.LongestContinuousApolarSegmentFilter

Bases: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter

This filter computes the longest continuous stretch of polar residues within a pose or selection.

apply(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool

returns true if the structure passes the filter, false otherwise

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::apply(const class core::pose::Pose &) const –> bool

class_name() → str

C++: protocols::simple_filters::LongestContinuousApolarSegmentFilter::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousApolarSegmentFilter) → pyrosetta.rosetta.protocols.filters.Filter

required in the context of the parser/scripting scheme

C++: protocols::simple_filters::LongestContinuousApolarSegmentFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

count_gly_as_polar(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter) → bool

Get whether glycine is counted as a polar residue type.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::count_gly_as_polar() const –> bool

counted_residue_description(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousApolarSegmentFilter) → str

returns type of counted residues (apolar)

C++: protocols::simple_filters::LongestContinuousApolarSegmentFilter::counted_residue_description() const –> std::string

cutoff(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter) → int

Get the max (or min) tolerated number of polars.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::cutoff() const –> unsigned long

exclude_chain_termini(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter) → bool

Get whether I should exclude stretches of polars are the N- and C-termini of chains.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::exclude_chain_termini() const –> bool

filter_out_high(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter) → bool

Get whether I should filter out high (true) or low (false) poses.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::filter_out_high() const –> bool

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousApolarSegmentFilter) → pyrosetta.rosetta.protocols.filters.Filter

required in the context of the parser/scripting scheme

C++: protocols::simple_filters::LongestContinuousApolarSegmentFilter::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

is_counted(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousApolarSegmentFilter, restype: pyrosetta.rosetta.core.chemical.ResidueType) → bool

Given a residue type, determine whether it’s one of the types that this filter

should count.

Based on whether the residue type has the APOLAR property.

C++: protocols::simple_filters::LongestContinuousApolarSegmentFilter::is_counted(const class core::chemical::ResidueType &) const –> bool

name(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousApolarSegmentFilter) → str

C++: protocols::simple_filters::LongestContinuousApolarSegmentFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, 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 Filter in Rosetta Scripts)

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::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::simple_filters::LongestContinuousApolarSegmentFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, os: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None

allows printing data to a stream

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

required for reporting score values

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::report_sm(const class core::pose::Pose &) const –> double

residue_selector(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector

Get the residue selector.

Can be shared, or modified later – this is a true owning pointer to the stored selector, not to a clone.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::residue_selector() const –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_count_gly_as_polar(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, setting: bool) → None

Set whether glycine is counted as a polar residue type.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::set_count_gly_as_polar(const bool) –> void

set_cutoff(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, cutoff: int) → None

Set the max (or min) tolerated number of polars.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::set_cutoff(const unsigned long) –> void

set_exclude_chain_termini(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, setting: bool) → None

Set whether I should exclude stretches of polars are the N- and C-termini of chains.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::set_exclude_chain_termini(const bool) –> void

set_filter_out_high(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, setting: bool) → None

Set whether I should filter out high (true) or low (false) poses.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::set_filter_out_high(const bool) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, selector_in: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None

Set the residue selector.

Does not clone the input; uses it directly. (Can be shared, or modified later).

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::set_residue_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter

This filter computes the longest continuous stretch of polar residues within a pose or selection.

apply(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool

returns true if the structure passes the filter, false otherwise

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::apply(const class core::pose::Pose &) const –> bool

class_name() → str

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter) → pyrosetta.rosetta.protocols.filters.Filter

required in the context of the parser/scripting scheme

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

count_gly_as_polar(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter) → bool

Get whether glycine is counted as a polar residue type.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::count_gly_as_polar() const –> bool

counted_residue_description(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter) → str

returns type of counted residues (polar)

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::counted_residue_description() const –> std::string

cutoff(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter) → int

Get the max (or min) tolerated number of polars.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::cutoff() const –> unsigned long

exclude_chain_termini(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter) → bool

Get whether I should exclude stretches of polars are the N- and C-termini of chains.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::exclude_chain_termini() const –> bool

filter_out_high(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter) → bool

Get whether I should filter out high (true) or low (false) poses.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::filter_out_high() const –> bool

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter) → pyrosetta.rosetta.protocols.filters.Filter

required in the context of the parser/scripting scheme

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

is_counted(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, restype: pyrosetta.rosetta.core.chemical.ResidueType) → bool

Given a residue type, determine whether it’s one of the types that this filter

should count.

Based on whether the residue type has the POLAR property. Special-case exception is made for glycine, depending on whether count_gly_as_polar_ is true.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::is_counted(const class core::chemical::ResidueType &) const –> bool

name(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter) → str

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, 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 Filter in Rosetta Scripts)

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::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::simple_filters::LongestContinuousPolarSegmentFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, os: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None

allows printing data to a stream

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

required for reporting score values

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::report_sm(const class core::pose::Pose &) const –> double

residue_selector(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter) → pyrosetta.rosetta.core.select.residue_selector.ResidueSelector

Get the residue selector.

Can be shared, or modified later – this is a true owning pointer to the stored selector, not to a clone.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::residue_selector() const –> class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_count_gly_as_polar(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, setting: bool) → None

Set whether glycine is counted as a polar residue type.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::set_count_gly_as_polar(const bool) –> void

set_cutoff(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, cutoff: int) → None

Set the max (or min) tolerated number of polars.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::set_cutoff(const unsigned long) –> void

set_exclude_chain_termini(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, setting: bool) → None

Set whether I should exclude stretches of polars are the N- and C-termini of chains.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::set_exclude_chain_termini(const bool) –> void

set_filter_out_high(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, setting: bool) → None

Set whether I should filter out high (true) or low (false) poses.

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::set_filter_out_high(const bool) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.simple_filters.LongestContinuousPolarSegmentFilter, selector_in: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None

Set the residue selector.

Does not clone the input; uses it directly. (Can be shared, or modified later).

C++: protocols::simple_filters::LongestContinuousPolarSegmentFilter::set_residue_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.simple_filters.NativeEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the NativeEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.NativeEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::NativeEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.NativeEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.NativeEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.NativeEvaluatorCreator

C++: protocols::simple_filters::NativeEvaluatorCreator::operator=(const class protocols::simple_filters::NativeEvaluatorCreator &) –> class protocols::simple_filters::NativeEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.NativeEvaluatorCreator) → None

C++: protocols::simple_filters::NativeEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.NativeEvaluatorCreator) → str

C++: protocols::simple_filters::NativeEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.simple_filters.PackerNeighborGraphFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter

filter that creates a packer neighbor graph of the pose

in every apply function and returns true if this graph

satisfies a specified connectivity

add_required_connection_for_residue(self: pyrosetta.rosetta.protocols.simple_filters.PackerNeighborGraphFilter, residue: int) → None

note: will increase required connections for this residue by 1

C++: protocols::simple_filters::PackerNeighborGraphFilter::add_required_connection_for_residue(unsigned long) –> void

add_required_connections_between_regions(self: pyrosetta.rosetta.protocols.simple_filters.PackerNeighborGraphFilter, region1: pyrosetta.rosetta.std.set_unsigned_long_t, region2: pyrosetta.rosetta.std.set_unsigned_long_t, required_connections: int) → None

C++: protocols::simple_filters::PackerNeighborGraphFilter::add_required_connections_between_regions(const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &, const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &, unsigned long) –> void

apply(self: pyrosetta.rosetta.protocols.simple_filters.PackerNeighborGraphFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool

Returns true if the given pose passes the filter, false otherwise.

C++: protocols::simple_filters::PackerNeighborGraphFilter::apply(const class core::pose::Pose &) const –> bool

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.PackerNeighborGraphFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::PackerNeighborGraphFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.PackerNeighborGraphFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::PackerNeighborGraphFilter::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

name(self: pyrosetta.rosetta.protocols.simple_filters.PackerNeighborGraphFilter) → str

C++: protocols::simple_filters::PackerNeighborGraphFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap, : pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::filters::Filter::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

report(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::filters::Filter::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::report_sm(const class core::pose::Pose &) const –> double

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_required_connections_for_residue(self: pyrosetta.rosetta.protocols.simple_filters.PackerNeighborGraphFilter, residue: int, required_connections: int) → None

note: will overwrite if information for this residue has already been entered

C++: protocols::simple_filters::PackerNeighborGraphFilter::set_required_connections_for_residue(unsigned long, unsigned long) –> void

set_task(self: pyrosetta.rosetta.protocols.simple_filters.PackerNeighborGraphFilter, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None

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

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.simple_filters.PalesEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the PalesEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.PalesEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::PalesEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.PalesEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.PalesEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.PalesEvaluatorCreator

C++: protocols::simple_filters::PalesEvaluatorCreator::operator=(const class protocols::simple_filters::PalesEvaluatorCreator &) –> class protocols::simple_filters::PalesEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.PalesEvaluatorCreator) → None

C++: protocols::simple_filters::PalesEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.PalesEvaluatorCreator) → str

C++: protocols::simple_filters::PalesEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.simple_filters.PoolEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the PoolEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.PoolEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::PoolEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.PoolEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.PoolEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.PoolEvaluatorCreator

C++: protocols::simple_filters::PoolEvaluatorCreator::operator=(const class protocols::simple_filters::PoolEvaluatorCreator &) –> class protocols::simple_filters::PoolEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.PoolEvaluatorCreator) → None

C++: protocols::simple_filters::PoolEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.PoolEvaluatorCreator) → str

C++: protocols::simple_filters::PoolEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.simple_filters.PoseComment

Bases: pyrosetta.rosetta.protocols.filters.Filter

test whether a pose contains a comment that evaluates to a predefined value. This is useful in controlling execution flow in RosettaScripts.

apply(self: pyrosetta.rosetta.protocols.simple_filters.PoseComment, pose: pyrosetta.rosetta.core.pose.Pose) → bool

C++: protocols::simple_filters::PoseComment::apply(const class core::pose::Pose &) const –> bool

class_name() → str

C++: protocols::simple_filters::PoseComment::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.PoseComment) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::PoseComment::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

comment_exists(*args, **kwargs)

Overloaded function.

1. comment_exists(self: pyrosetta.rosetta.protocols.simple_filters.PoseComment) -> bool

C++: protocols::simple_filters::PoseComment::comment_exists() const –> bool

2. comment_exists(self: pyrosetta.rosetta.protocols.simple_filters.PoseComment, c: bool) -> None

C++: protocols::simple_filters::PoseComment::comment_exists(const bool) –> void

comment_name(*args, **kwargs)

Overloaded function.

1. comment_name(self: pyrosetta.rosetta.protocols.simple_filters.PoseComment) -> str

C++: protocols::simple_filters::PoseComment::comment_name() const –> std::string

2. comment_name(self: pyrosetta.rosetta.protocols.simple_filters.PoseComment, s: str) -> None

C++: protocols::simple_filters::PoseComment::comment_name(const class std::basic_string<char> &) –> void

comment_value(*args, **kwargs)

Overloaded function.

1. comment_value(self: pyrosetta.rosetta.protocols.simple_filters.PoseComment) -> str

C++: protocols::simple_filters::PoseComment::comment_value() const –> std::string

2. comment_value(self: pyrosetta.rosetta.protocols.simple_filters.PoseComment, s: str) -> None

C++: protocols::simple_filters::PoseComment::comment_value(const class std::basic_string<char> &) –> void

compute(self: pyrosetta.rosetta.protocols.simple_filters.PoseComment, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::PoseComment::compute(const class core::pose::Pose &) const –> double

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.PoseComment) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::PoseComment::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

name(self: pyrosetta.rosetta.protocols.simple_filters.PoseComment) → str

C++: protocols::simple_filters::PoseComment::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.simple_filters.PoseComment, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::PoseComment::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::simple_filters::PoseComment::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.simple_filters.PoseComment, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::PoseComment::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.simple_filters.PoseComment, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::PoseComment::report_sm(const class core::pose::Pose &) const –> double

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.simple_filters.PoseInfoFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter

detects atomic contacts between two atoms of two residues

apply(self: pyrosetta.rosetta.protocols.simple_filters.PoseInfoFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool

C++: protocols::simple_filters::PoseInfoFilter::apply(const class core::pose::Pose &) const –> bool

class_name() → str

C++: protocols::simple_filters::PoseInfoFilter::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.PoseInfoFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::PoseInfoFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.simple_filters.PoseInfoFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::PoseInfoFilter::compute(const class core::pose::Pose &) const –> double

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.PoseInfoFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::PoseInfoFilter::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

name(self: pyrosetta.rosetta.protocols.simple_filters.PoseInfoFilter) → str

C++: protocols::simple_filters::PoseInfoFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.simple_filters.PoseInfoFilter, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap, : pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::PoseInfoFilter::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::simple_filters::PoseInfoFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.simple_filters.PoseInfoFilter, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::PoseInfoFilter::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.simple_filters.PoseInfoFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::PoseInfoFilter::report_sm(const class core::pose::Pose &) const –> double

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.simple_filters.PredictedBurialFnEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the PredictedBurialFnEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.PredictedBurialFnEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::PredictedBurialFnEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.PredictedBurialFnEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.PredictedBurialFnEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.PredictedBurialFnEvaluatorCreator

C++: protocols::simple_filters::PredictedBurialFnEvaluatorCreator::operator=(const class protocols::simple_filters::PredictedBurialFnEvaluatorCreator &) –> class protocols::simple_filters::PredictedBurialFnEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.PredictedBurialFnEvaluatorCreator) → None

C++: protocols::simple_filters::PredictedBurialFnEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.PredictedBurialFnEvaluatorCreator) → str

C++: protocols::simple_filters::PredictedBurialFnEvaluatorCreator::type_name() const –> std::string

pyrosetta.rosetta.protocols.simple_filters.R2quat(R: pyrosetta.rosetta.numeric.xyzMatrix_double_t, Q: pyrosetta.rosetta.protocols.simple_filters.Quat) → None

C++: protocols::simple_filters::R2quat(class numeric::xyzMatrix<double>, struct protocols::simple_filters::Quat &) –> void

pyrosetta.rosetta.protocols.simple_filters.RMSwrapper(chainA: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t, chainB: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t, R: pyrosetta.rosetta.numeric.xyzMatrix_double_t, preT: pyrosetta.rosetta.numeric.xyzVector_double_t, postT: pyrosetta.rosetta.numeric.xyzVector_double_t) → float

C++: protocols::simple_filters::RMSwrapper(class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > >, class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > >, class numeric::xyzMatrix<double> &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) –> double

class pyrosetta.rosetta.protocols.simple_filters.RdcEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the RdcEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.RdcEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::RdcEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.RdcEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.RdcEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.RdcEvaluatorCreator

C++: protocols::simple_filters::RdcEvaluatorCreator::operator=(const class protocols::simple_filters::RdcEvaluatorCreator &) –> class protocols::simple_filters::RdcEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.RdcEvaluatorCreator) → None

C++: protocols::simple_filters::RdcEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.RdcEvaluatorCreator) → str

C++: protocols::simple_filters::RdcEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.simple_filters.RdcSelectEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the RdcSelectEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.RdcSelectEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::RdcSelectEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.RdcSelectEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.RdcSelectEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.RdcSelectEvaluatorCreator

C++: protocols::simple_filters::RdcSelectEvaluatorCreator::operator=(const class protocols::simple_filters::RdcSelectEvaluatorCreator &) –> class protocols::simple_filters::RdcSelectEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.RdcSelectEvaluatorCreator) → None

C++: protocols::simple_filters::RdcSelectEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.RdcSelectEvaluatorCreator) → str

C++: protocols::simple_filters::RdcSelectEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.simple_filters.RdcTargetEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the RdcTargetEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.RdcTargetEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::RdcTargetEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.RdcTargetEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.RdcTargetEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.RdcTargetEvaluatorCreator

C++: protocols::simple_filters::RdcTargetEvaluatorCreator::operator=(const class protocols::simple_filters::RdcTargetEvaluatorCreator &) –> class protocols::simple_filters::RdcTargetEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.RdcTargetEvaluatorCreator) → None

C++: protocols::simple_filters::RdcTargetEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.RdcTargetEvaluatorCreator) → str

C++: protocols::simple_filters::RdcTargetEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.simple_filters.RegionalConnections

Bases: pybind11_builtins.pybind11_object

helper class for PackerNeighborGraphFilter

assign(self: pyrosetta.rosetta.protocols.simple_filters.RegionalConnections, : pyrosetta.rosetta.protocols.simple_filters.RegionalConnections) → pyrosetta.rosetta.protocols.simple_filters.RegionalConnections

C++: protocols::simple_filters::RegionalConnections::operator=(const class protocols::simple_filters::RegionalConnections &) –> class protocols::simple_filters::RegionalConnections &

check_if_connected_residues_belong_to_regions(self: pyrosetta.rosetta.protocols.simple_filters.RegionalConnections, res1: int, res2: int) → None

C++: protocols::simple_filters::RegionalConnections::check_if_connected_residues_belong_to_regions(unsigned long, unsigned long) const –> void

enough_connections(self: pyrosetta.rosetta.protocols.simple_filters.RegionalConnections) → bool

C++: protocols::simple_filters::RegionalConnections::enough_connections() const –> bool

region1(self: pyrosetta.rosetta.protocols.simple_filters.RegionalConnections) → pyrosetta.rosetta.std.set_unsigned_long_t

C++: protocols::simple_filters::RegionalConnections::region1() const –> const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &

region2(self: pyrosetta.rosetta.protocols.simple_filters.RegionalConnections) → pyrosetta.rosetta.std.set_unsigned_long_t

C++: protocols::simple_filters::RegionalConnections::region2() const –> const class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> > &

reset_num_connections(self: pyrosetta.rosetta.protocols.simple_filters.RegionalConnections) → None

C++: protocols::simple_filters::RegionalConnections::reset_num_connections() const –> void

class pyrosetta.rosetta.protocols.simple_filters.ResidueDepthCalculator

Bases: pybind11_builtins.pybind11_object

assign(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthCalculator, : pyrosetta.rosetta.protocols.simple_filters.ResidueDepthCalculator) → pyrosetta.rosetta.protocols.simple_filters.ResidueDepthCalculator

C++: protocols::simple_filters::ResidueDepthCalculator::operator=(const class protocols::simple_filters::ResidueDepthCalculator &) –> class protocols::simple_filters::ResidueDepthCalculator &

estimate_sidechain_depth(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthCalculator, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_double

C++: protocols::simple_filters::ResidueDepthCalculator::estimate_sidechain_depth(const class core::pose::Pose &) const –> class utility::vector1<double, class std::allocator<double> >

get_scdepth_avrg(*args, **kwargs)

Overloaded function.

1. get_scdepth_avrg(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthCalculator, ires: int) -> float

C++: protocols::simple_filters::ResidueDepthCalculator::get_scdepth_avrg(const unsigned long) const –> double

2. get_scdepth_avrg(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthCalculator) -> pyrosetta.rosetta.utility.vector1_double

C++: protocols::simple_filters::ResidueDepthCalculator::get_scdepth_avrg() const –> class utility::vector1<double, class std::allocator<double> >

get_scdepth_fvar(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthCalculator) → pyrosetta.rosetta.utility.vector1_double

C++: protocols::simple_filters::ResidueDepthCalculator::get_scdepth_fvar() const –> class utility::vector1<double, class std::allocator<double> >

get_scdepth_sdev(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthCalculator) → pyrosetta.rosetta.utility.vector1_double

C++: protocols::simple_filters::ResidueDepthCalculator::get_scdepth_sdev() const –> class utility::vector1<double, class std::allocator<double> >

niter(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthCalculator, value: int) → None

C++: protocols::simple_filters::ResidueDepthCalculator::niter(const unsigned long) –> void

nres(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthCalculator) → int

C++: protocols::simple_filters::ResidueDepthCalculator::nres() const –> unsigned long

report_crd(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthCalculator, value: bool) → None

C++: protocols::simple_filters::ResidueDepthCalculator::report_crd(const bool) –> void

set_dcut1(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthCalculator, value: float) → None

C++: protocols::simple_filters::ResidueDepthCalculator::set_dcut1(const double) –> void

set_dcut2(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthCalculator, value: float) → None

C++: protocols::simple_filters::ResidueDepthCalculator::set_dcut2(const double) –> void

class pyrosetta.rosetta.protocols.simple_filters.ResidueDepthData

Bases: pybind11_builtins.pybind11_object

assign(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthData, : pyrosetta.rosetta.protocols.simple_filters.ResidueDepthData) → pyrosetta.rosetta.protocols.simple_filters.ResidueDepthData

C++: protocols::simple_filters::ResidueDepthData::operator=(const struct protocols::simple_filters::ResidueDepthData &) –> struct protocols::simple_filters::ResidueDepthData &

class pyrosetta.rosetta.protocols.simple_filters.ResidueDepthFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter

apply(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthFilter, : pyrosetta.rosetta.core.pose.Pose) → bool

C++: protocols::simple_filters::ResidueDepthFilter::apply(const class core::pose::Pose &) const –> bool

class_name() → str

C++: protocols::simple_filters::ResidueDepthFilter::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::ResidueDepthFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthFilter) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::ResidueDepthFilter::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_SDE_score(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::ResidueDepthFilter::get_SDE_score(const class core::pose::Pose &) –> double

get_residue_depth(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthFilter, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_double

C++: protocols::simple_filters::ResidueDepthFilter::get_residue_depth(const class core::pose::Pose &) const –> class utility::vector1<double, class std::allocator<double> >

get_scdepth_avrg(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthFilter) → pyrosetta.rosetta.utility.vector1_double

C++: protocols::simple_filters::ResidueDepthFilter::get_scdepth_avrg() const –> class utility::vector1<double, class std::allocator<double> >

get_scdepth_fvar(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthFilter) → pyrosetta.rosetta.utility.vector1_double

C++: protocols::simple_filters::ResidueDepthFilter::get_scdepth_fvar() const –> class utility::vector1<double, class std::allocator<double> >

get_scdepth_sdev(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthFilter) → pyrosetta.rosetta.utility.vector1_double

C++: protocols::simple_filters::ResidueDepthFilter::get_scdepth_sdev() const –> class utility::vector1<double, class std::allocator<double> >

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

name(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthFilter) → str

C++: protocols::simple_filters::ResidueDepthFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthFilter, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap, : pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::ResidueDepthFilter::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::simple_filters::ResidueDepthFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::filters::Filter::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::report_sm(const class core::pose::Pose &) const –> double

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_niter(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthFilter, value: int) → None

C++: protocols::simple_filters::ResidueDepthFilter::set_niter(const unsigned long) –> void

set_report_crd(self: pyrosetta.rosetta.protocols.simple_filters.ResidueDepthFilter, value: bool) → None

C++: protocols::simple_filters::ResidueDepthFilter::set_report_crd(const bool) –> void

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.simple_filters.RmsdEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the RmsdEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.RmsdEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::RmsdEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.RmsdEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.RmsdEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.RmsdEvaluatorCreator

C++: protocols::simple_filters::RmsdEvaluatorCreator::operator=(const class protocols::simple_filters::RmsdEvaluatorCreator &) –> class protocols::simple_filters::RmsdEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.RmsdEvaluatorCreator) → None

C++: protocols::simple_filters::RmsdEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.RmsdEvaluatorCreator) → str

C++: protocols::simple_filters::RmsdEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.simple_filters.RmsdTargetEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the RmsdTargetEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.RmsdTargetEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::RmsdTargetEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.RmsdTargetEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.RmsdTargetEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.RmsdTargetEvaluatorCreator

C++: protocols::simple_filters::RmsdTargetEvaluatorCreator::operator=(const class protocols::simple_filters::RmsdTargetEvaluatorCreator &) –> class protocols::simple_filters::RmsdTargetEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.RmsdTargetEvaluatorCreator) → None

C++: protocols::simple_filters::RmsdTargetEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.RmsdTargetEvaluatorCreator) → str

C++: protocols::simple_filters::RmsdTargetEvaluatorCreator::type_name() const –> std::string

class pyrosetta.rosetta.protocols.simple_filters.ScoreEvaluator

Bases: pyrosetta.rosetta.protocols.evaluation.SingleValuePoseEvaluator_double_t

that rewrites the whole pss struct all previous entries will be lost… probably not what one wants…

applicable(self: pyrosetta.rosetta.protocols.simple_filters.ScoreEvaluator, pose: pyrosetta.rosetta.core.pose.Pose) → bool

C++: protocols::simple_filters::ScoreEvaluator::applicable(const class core::pose::Pose &) const –> bool

apply(self: pyrosetta.rosetta.protocols.simple_filters.ScoreEvaluator, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::ScoreEvaluator::apply(class core::pose::Pose &) const –> double

assign(self: pyrosetta.rosetta.protocols.simple_filters.ScoreEvaluator, : pyrosetta.rosetta.protocols.simple_filters.ScoreEvaluator) → pyrosetta.rosetta.protocols.simple_filters.ScoreEvaluator

C++: protocols::simple_filters::ScoreEvaluator::operator=(const class protocols::simple_filters::ScoreEvaluator &) –> class protocols::simple_filters::ScoreEvaluator &

name(*args, **kwargs)

Overloaded function.

1. name(self: pyrosetta.rosetta.protocols.evaluation.SingleValuePoseEvaluator_double_t, : int) -> str

C++: protocols::evaluation::SingleValuePoseEvaluator<double>::name(unsigned long) const –> std::string

2. name(self: pyrosetta.rosetta.protocols.evaluation.SingleValuePoseEvaluator_double_t, : int) -> str

C++: protocols::evaluation::PoseEvaluator::name(unsigned long) const –> std::string

size(*args, **kwargs)

Overloaded function.

1. size(self: pyrosetta.rosetta.protocols.evaluation.SingleValuePoseEvaluator_double_t) -> int

C++: protocols::evaluation::SingleValuePoseEvaluator<double>::size() const –> unsigned long

2. size(self: pyrosetta.rosetta.protocols.evaluation.SingleValuePoseEvaluator_double_t) -> int

C++: protocols::evaluation::PoseEvaluator::size() const –> unsigned long

class pyrosetta.rosetta.protocols.simple_filters.SequenceDistance

Bases: pyrosetta.rosetta.protocols.filters.Filter

test whether a pose contains a comment that evaluates to a predefined value. This is useful in controlling execution flow in RosettaScripts.

apply(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance, pose: pyrosetta.rosetta.core.pose.Pose) → bool

C++: protocols::simple_filters::SequenceDistance::apply(const class core::pose::Pose &) const –> bool

class_name() → str

C++: protocols::simple_filters::SequenceDistance::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::SequenceDistance::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance, pose: pyrosetta.rosetta.core.pose.Pose) → int

C++: protocols::simple_filters::SequenceDistance::compute(const class core::pose::Pose &) const –> unsigned long

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance) → pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::simple_filters::SequenceDistance::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

name(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance) → str

C++: protocols::simple_filters::SequenceDistance::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::SequenceDistance::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

pose_seq(*args, **kwargs)

Overloaded function.

1. pose_seq(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance) -> str

C++: protocols::simple_filters::SequenceDistance::pose_seq() const –> std::string

2. pose_seq(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance, s: str) -> None

C++: protocols::simple_filters::SequenceDistance::pose_seq(const class std::basic_string<char> &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::simple_filters::SequenceDistance::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::simple_filters::SequenceDistance::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::simple_filters::SequenceDistance::report_sm(const class core::pose::Pose &) const –> double

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

sequence_comment_id(*args, **kwargs)

Overloaded function.

1. sequence_comment_id(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance) -> str

C++: protocols::simple_filters::SequenceDistance::sequence_comment_id() const –> std::string

2. sequence_comment_id(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance, s: str) -> None

C++: protocols::simple_filters::SequenceDistance::sequence_comment_id(const class std::basic_string<char> &) –> void

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

target_seq(*args, **kwargs)

Overloaded function.

1. target_seq(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance) -> str

C++: protocols::simple_filters::SequenceDistance::target_seq() const –> std::string

2. target_seq(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance, s: str) -> None

C++: protocols::simple_filters::SequenceDistance::target_seq(const class std::basic_string<char> &) –> void

threshold(*args, **kwargs)

Overloaded function.

1. threshold(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance) -> int

C++: protocols::simple_filters::SequenceDistance::threshold() const –> unsigned long

2. threshold(self: pyrosetta.rosetta.protocols.simple_filters.SequenceDistance, t: int) -> None

C++: protocols::simple_filters::SequenceDistance::threshold(const unsigned long &) –> void

class pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter

Simple filter for detercting Hbonds to atom with energy < energy cutoff

apply(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool

returns true if the structure passes the filter, false otherwise

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::apply(const class core::pose::Pose &) const –> bool

class_name() → str

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter) → pyrosetta.rosetta.protocols.filters.Filter

required in the context of the parser/scripting scheme

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter, pose: pyrosetta.rosetta.core.pose.Pose) → int

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::compute(const class core::pose::Pose &) const –> unsigned long

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter) → pyrosetta.rosetta.protocols.filters.Filter

required in the context of the parser/scripting scheme

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_hb_e_cutoff(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter) → float

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::get_hb_e_cutoff() const –> double

get_n_partners(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter) → int

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::get_n_partners() const –> unsigned long

get_scorefxn(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::get_scorefxn() const –> class std::shared_ptr<class core::scoring::ScoreFunction>

get_target_atom_name(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter) → str

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::get_target_atom_name() const –> std::string

get_target_residue(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter) → str

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::get_target_residue() const –> const std::string &

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

name(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter) → str

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter, 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 Filter in Rosetta Scripts)

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::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::simple_filters::SimpleHbondsToAtomFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter, os: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None

allows printing data to a stream

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

required for reporting score values

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::report_sm(const class core::pose::Pose &) const –> double

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_hb_e_cutoff(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter, hb_e_cutoff: float) → None

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::set_hb_e_cutoff(double) –> void

set_n_partners(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter, n_partners: int) → None

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::set_n_partners(unsigned long) –> void

set_scorefxn(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::set_scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_target_atom_name(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter, atom_name: str) → None

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::set_target_atom_name(class std::basic_string<char>) –> void

set_target_residue(self: pyrosetta.rosetta.protocols.simple_filters.SimpleHbondsToAtomFilter, target_residue: str) → None

C++: protocols::simple_filters::SimpleHbondsToAtomFilter::set_target_residue(const class std::basic_string<char> &) –> void

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.simple_filters.SimpleMetricFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter

A filter takes any SimpleMetric and applies a set cutoff to filter the model.

Set the cutoff type to set the behavior of the metric.

Compares metric_value to cutoff_value or match_value

match_value is used for strings, cutoff is used for numbers.

So, if comparison_type is set to eq, if metric_value eq the cutoff_value we return true.

RMSD example: set to lt, and the filter will pass with a metric value anything less than the cuttoff.

CompositeMetrics take an extra parameter, composite_action.

Composite action can be “any”, “all”, or any specific composite metric value you want to match on.

Any: If any match the set criteria, we return true All: If all match the set criteria, we return true etc: If the particular metric of the composite metric (ex fa_rep for the CompositeEnergyMetric), matches the criteria,

we return true.

See Methods:

set_comparison_type(), set_composite_action(), set_cutoff_value(), set_match_string()

apply(self: pyrosetta.rosetta.protocols.simple_filters.SimpleMetricFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool

returns true if the structure passes the filter, false otherwise

C++: protocols::simple_filters::SimpleMetricFilter::apply(const class core::pose::Pose &) const –> bool

class_name() → str

C++: protocols::simple_filters::SimpleMetricFilter::class_name() –> std::string

clear(self: pyrosetta.rosetta.protocols.filters.Filter) → None

used to clear internal variables if needed. Using fresh_instance is preferred since it’s a pure virtual

C++: protocols::filters::Filter::clear() –> void

clone(self: pyrosetta.rosetta.protocols.simple_filters.SimpleMetricFilter) → pyrosetta.rosetta.protocols.filters.Filter

required in the context of the parser/scripting scheme

C++: protocols::simple_filters::SimpleMetricFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

fresh_instance(self: pyrosetta.rosetta.protocols.simple_filters.SimpleMetricFilter) → pyrosetta.rosetta.protocols.filters.Filter

required in the context of the parser/scripting scheme

C++: protocols::simple_filters::SimpleMetricFilter::fresh_instance() const –> class std::shared_ptr<class protocols::filters::Filter>

get_type(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_type() const –> std::string

get_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter) → str

C++: protocols::filters::Filter::get_user_defined_name() const –> std::string

name(self: pyrosetta.rosetta.protocols.simple_filters.SimpleMetricFilter) → str

C++: protocols::simple_filters::SimpleMetricFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.simple_filters.SimpleMetricFilter, 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 Filter in Rosetta Scripts)

C++: protocols::simple_filters::SimpleMetricFilter::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::simple_filters::SimpleMetricFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::filters::Filter::report(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.simple_filters.SimpleMetricFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

required for reporting score values

C++: protocols::simple_filters::SimpleMetricFilter::report_sm(const class core::pose::Pose &) const –> double

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

set_comparison_type(self: pyrosetta.rosetta.protocols.simple_filters.SimpleMetricFilter, co_type: pyrosetta.rosetta.protocols.simple_filters.comparison_type) → None

Sets the cutoff type - aka eq, ne, etc. Options are:

eq, ne, lt, gt, lt_or_eq, gt_or_eq.

If this is a StringMetric, only eq and ne are relevant here. IF value [comparison_type] cutoff_ return True.

C++: protocols::simple_filters::SimpleMetricFilter::set_comparison_type(enum protocols::simple_filters::comparison_type) –> void

set_composite_action(self: pyrosetta.rosetta.protocols.simple_filters.SimpleMetricFilter, composite_action: str) → None

Set the action we take for a set CompositeMetric

Composite action can be “any”, “all”, or any specific composite metric value you want to match on. See Also: set_comparison_type(), set_cutoff

Any: If any match the set criteria, we return true All: If all match the set criteria, we return true etc: If the particular metric of the composite metric (ex fa_rep for the CompositeEnergyMetric), matches the criteria,

we return true.

C++: protocols::simple_filters::SimpleMetricFilter::set_composite_action(const class std::basic_string<char> &) –> void

set_cutoff(self: pyrosetta.rosetta.protocols.simple_filters.SimpleMetricFilter, cutoff: float) → None

Set the cutoff value for any RealMetric or CompositeRealMetric.

C++: protocols::simple_filters::SimpleMetricFilter::set_cutoff(double) –> void

set_epsilon(self: pyrosetta.rosetta.protocols.simple_filters.SimpleMetricFilter, epsilon: float) → None

Set the sigfigs we will use in our comparisons.

Default is .0001;

C++: protocols::simple_filters::SimpleMetricFilter::set_epsilon(double) –> void

set_match_string(self: pyrosetta.rosetta.protocols.simple_filters.SimpleMetricFilter, match_string: str) → None

Set the match value for any StringMetric or CompositeStringMetric.

C++: protocols::simple_filters::SimpleMetricFilter::set_match_string(const class std::basic_string<char> &) –> void

set_simple_metric(self: pyrosetta.rosetta.protocols.simple_filters.SimpleMetricFilter, metric: pyrosetta.rosetta.core.simple_metrics.SimpleMetric) → None

Set the SimpleMetric that we will be using to filter.

C++: protocols::simple_filters::SimpleMetricFilter::set_simple_metric(class std::shared_ptr<const class core::simple_metrics::SimpleMetric>) –> void

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None

C++: protocols::filters::Filter::set_user_defined_name(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.simple_filters.StructureSimilarityEvaluatorCreator

Bases: pyrosetta.rosetta.protocols.evaluation.EvaluatorCreator

creator for the StructureSimilarityEvaluatorCreator class

add_evaluators(self: pyrosetta.rosetta.protocols.simple_filters.StructureSimilarityEvaluatorCreator, eval: pyrosetta.rosetta.protocols.evaluation.MetaPoseEvaluator) → None

C++: protocols::simple_filters::StructureSimilarityEvaluatorCreator::add_evaluators(class protocols::evaluation::MetaPoseEvaluator &) const –> void

assign(self: pyrosetta.rosetta.protocols.simple_filters.StructureSimilarityEvaluatorCreator, : pyrosetta.rosetta.protocols.simple_filters.StructureSimilarityEvaluatorCreator) → pyrosetta.rosetta.protocols.simple_filters.StructureSimilarityEvaluatorCreator

C++: protocols::simple_filters::StructureSimilarityEvaluatorCreator::operator=(const class protocols::simple_filters::StructureSimilarityEvaluatorCreator &) –> class protocols::simple_filters::StructureSimilarityEvaluatorCreator &

register_options(self: pyrosetta.rosetta.protocols.simple_filters.StructureSimilarityEvaluatorCreator) → None

C++: protocols::simple_filters::StructureSimilarityEvaluatorCreator::register_options() –> void

type_name(self: pyrosetta.rosetta.protocols.simple_filters.StructureSimilarityEvaluatorCreator) → str

C++: protocols::simple_filters::StructureSimilarityEvaluatorCreator::type_name() const –> std::string

pyrosetta.rosetta.protocols.simple_filters.atom_distance(r1: pyrosetta.rosetta.core.conformation.Residue, a1: str, r2: pyrosetta.rosetta.core.conformation.Residue, a2: str) → float

compute the atomic distance between two atoms on two residues

C++: protocols::simple_filters::atom_distance(const class core::conformation::Residue &, const class std::basic_string<char> &, const class core::conformation::Residue &, const class std::basic_string<char> &) –> double

class pyrosetta.rosetta.protocols.simple_filters.comparison_type

Bases: pybind11_builtins.pybind11_object

Enum that tells us how to interpret the cutoff set.

Members:

eq

ne

lt

gt

lt_or_eq

gt_or_eq

bogus

comparison_type_total

pyrosetta.rosetta.protocols.simple_filters.dssp(pose: pyrosetta.rosetta.core.pose.Pose) → str

read dssp for a pose and return a string

C++: protocols::simple_filters::dssp(const class core::pose::Pose &) –> std::string

pyrosetta.rosetta.protocols.simple_filters.get_string_comparison_type_strings() → pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::simple_filters::get_string_comparison_type_strings() –> class utility::vector1<std::string, class std::allocator<std::string > >

pyrosetta.rosetta.protocols.simple_filters.load_poses(filenames: pyrosetta.rosetta.utility.vector1_std_string) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_pose_Pose_t

load PDBs into a vector

C++: protocols::simple_filters::load_poses(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> class utility::vector1<class std::shared_ptr<class core::pose::Pose>, class std::allocator<class std::shared_ptr<class core::pose::Pose> > >

pyrosetta.rosetta.protocols.simple_filters.positions_in_secstruct(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long

find helix, sheet positions in dssp

C++: protocols::simple_filters::positions_in_secstruct(const class core::pose::Pose &) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.protocols.simple_filters.quat2R(Q: pyrosetta.rosetta.protocols.simple_filters.Quat, R: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → None

C++: protocols::simple_filters::quat2R(struct protocols::simple_filters::Quat &, class numeric::xyzMatrix<double>) –> void

pyrosetta.rosetta.protocols.simple_filters.res_res_min_distance(p1: pyrosetta.rosetta.core.pose.Pose, r1: int, p2: pyrosetta.rosetta.core.pose.Pose, r2: int) → float

find the minimal atom-atom distance between two residues

C++: protocols::simple_filters::res_res_min_distance(const class core::pose::Pose &, const unsigned long, const class core::pose::Pose &, const unsigned long) –> double