calc_taskop_filters¶

Bindings for protocols::calc_taskop_filters namespace

class pyrosetta.rosetta.protocols.calc_taskop_filters.ConservedPosMutationFilter¶

Bases: Filter

apply(self: pyrosetta.rosetta.protocols.calc_taskop_filters.ConservedPosMutationFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶

Returns true if the given pose passes the filter, false otherwise.: In this case, a pose passes if it less than max_allowed_conserved_pos_mutations_ mutations at conserved position. the decision whether a given position counts as conserved is made by the RestrictConservedLowDdgOperation task operation to prevent duplication of code

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

static class_name() → str¶: C++: protocols::calc_taskop_filters::ConservedPosMutationFilter::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.calc_taskop_filters.ConservedPosMutationFilter) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::ConservedPosMutationFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

fresh_instance(self: pyrosetta.rosetta.protocols.calc_taskop_filters.ConservedPosMutationFilter) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::ConservedPosMutationFilter::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.calc_taskop_filters.ConservedPosMutationFilter) → str¶: C++: protocols::calc_taskop_filters::ConservedPosMutationFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.calc_taskop_filters.ConservedPosMutationFilter, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::calc_taskop_filters::ConservedPosMutationFilter::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

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

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

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::calc_taskop_filters::ConservedPosMutationFilter::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(std::ostream &, 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_max_allowed_conserved_pos_mutations(self: pyrosetta.rosetta.protocols.calc_taskop_filters.ConservedPosMutationFilter, value: int) → None¶: C++: protocols::calc_taskop_filters::ConservedPosMutationFilter::set_max_allowed_conserved_pos_mutations(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 std::string &) –> void

class pyrosetta.rosetta.protocols.calc_taskop_filters.ConservedPosMutationFilterCreator¶

Bases: FilterCreator

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

create_filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.ConservedPosMutationFilterCreator) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::ConservedPosMutationFilterCreator::create_filter() const –> class std::shared_ptr<class protocols::filters::Filter>

keyname(self: pyrosetta.rosetta.protocols.calc_taskop_filters.ConservedPosMutationFilterCreator) → str¶: C++: protocols::calc_taskop_filters::ConservedPosMutationFilterCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.calc_taskop_filters.ConservedPosMutationFilterCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::calc_taskop_filters::ConservedPosMutationFilterCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids¶

Bases: Filter

simply takes a list of pdbs and creates relative pose then extract sigmoids and call operator (product)

apply(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: protocols::calc_taskop_filters::MultipleSigmoids::apply(const class core::pose::Pose &) const –> bool

static class_name() → str¶: C++: protocols::calc_taskop_filters::MultipleSigmoids::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.calc_taskop_filters.MultipleSigmoids) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::MultipleSigmoids::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::calc_taskop_filters::MultipleSigmoids::compute(const class core::pose::Pose &) const –> double

fresh_instance(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::MultipleSigmoids::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.calc_taskop_filters.MultipleSigmoids) → str¶

allows within-trajectory resetting of the baseline. Notice this is nonconst, so can’t be called from apply. attempt_read_from_checkpoint should be true for MC trials > 1, but false otherwise

C++: protocols::calc_taskop_filters::MultipleSigmoids::name() const –> std::string

operator_filter(*args, **kwargs)¶

Overloaded function.

operator_filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids) -> protocols::calc_taskop_filters::Operator

C++: protocols::calc_taskop_filters::MultipleSigmoids::operator_filter() const –> class std::shared_ptr<class protocols::calc_taskop_filters::Operator>

operator_filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids, opt: protocols::calc_taskop_filters::Operator) -> None

C++: protocols::calc_taskop_filters::MultipleSigmoids::operator_filter(class std::shared_ptr<class protocols::calc_taskop_filters::Operator>) –> void

parse_my_tag(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::calc_taskop_filters::MultipleSigmoids::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

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

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

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::calc_taskop_filters::MultipleSigmoids::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

relative_pose_filter(*args, **kwargs)¶

Overloaded function.

relative_pose_filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids) -> protocols::calc_taskop_filters::RelativePoseFilter

C++: protocols::calc_taskop_filters::MultipleSigmoids::relative_pose_filter() const –> class std::shared_ptr<class protocols::calc_taskop_filters::RelativePoseFilter>

relative_pose_filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids, rpose: protocols::calc_taskop_filters::RelativePoseFilter) -> None

C++: protocols::calc_taskop_filters::MultipleSigmoids::relative_pose_filter(class std::shared_ptr<class protocols::calc_taskop_filters::RelativePoseFilter>) –> void

report(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::calc_taskop_filters::MultipleSigmoids::report(std::ostream &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::calc_taskop_filters::MultipleSigmoids::report_sm(const class core::pose::Pose &) const –> double

reset_baseline(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids, pose: pyrosetta.rosetta.core.pose.Pose, attempt_read_from_checkpoint: bool) → None¶: C++: protocols::calc_taskop_filters::MultipleSigmoids::reset_baseline(const class core::pose::Pose &, const bool) –> void

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 std::string &) –> void

sigmoid_filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids) → protocols::calc_taskop_filters::Sigmoid¶: C++: protocols::calc_taskop_filters::MultipleSigmoids::sigmoid_filter() const –> class std::shared_ptr<class protocols::calc_taskop_filters::Sigmoid>

threshold(*args, **kwargs)¶

Overloaded function.

threshold(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids) -> float

C++: protocols::calc_taskop_filters::MultipleSigmoids::threshold() const –> double

threshold(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoids, t: float) -> None

C++: protocols::calc_taskop_filters::MultipleSigmoids::threshold(const double) –> void

class pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoidsFilterCreator¶

Bases: FilterCreator

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

create_filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoidsFilterCreator) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::MultipleSigmoidsFilterCreator::create_filter() const –> class std::shared_ptr<class protocols::filters::Filter>

keyname(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoidsFilterCreator) → str¶: C++: protocols::calc_taskop_filters::MultipleSigmoidsFilterCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.calc_taskop_filters.MultipleSigmoidsFilterCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::calc_taskop_filters::MultipleSigmoidsFilterCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.calc_taskop_filters.Operation¶

Bases: pybind11_object

Members:

SUM

PRODUCT

NORMALIZED_SUM

MAX

MIN

SUBTRACT

ABS

BOOLEAN_OR

XOR

ABS = <Operation.ABS: 6>¶

BOOLEAN_OR = <Operation.BOOLEAN_OR: 7>¶

MAX = <Operation.MAX: 3>¶

MIN = <Operation.MIN: 4>¶

NORMALIZED_SUM = <Operation.NORMALIZED_SUM: 2>¶

PRODUCT = <Operation.PRODUCT: 1>¶

SUBTRACT = <Operation.SUBTRACT: 5>¶

SUM = <Operation.SUM: 0>¶

XOR = <Operation.XOR: 8>¶

property name¶

property value¶

class pyrosetta.rosetta.protocols.calc_taskop_filters.Operator¶

Bases: Filter

simply take a list of filters and combine them using the operation above

add_filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator, f: pyrosetta.rosetta.protocols.filters.Filter) → None¶: C++: protocols::calc_taskop_filters::Operator::add_filter(class std::shared_ptr<class protocols::filters::Filter>) –> void

apply(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: protocols::calc_taskop_filters::Operator::apply(const class core::pose::Pose &) const –> bool

static attributes(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None¶: C++: protocols::calc_taskop_filters::Operator::attributes(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

static class_name() → str¶: C++: protocols::calc_taskop_filters::Operator::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.calc_taskop_filters.Operator) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::Operator::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::calc_taskop_filters::Operator::compute(const class core::pose::Pose &) const –> double

filters(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_filters_Filter_t¶: C++: protocols::calc_taskop_filters::Operator::filters() const –> class utility::vector1<class std::shared_ptr<class protocols::filters::Filter>, class std::allocator<class std::shared_ptr<class protocols::filters::Filter> > >

fresh_instance(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::Operator::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

logarithm(*args, **kwargs)¶

Overloaded function.

logarithm(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator) -> bool

C++: protocols::calc_taskop_filters::Operator::logarithm() const –> bool

logarithm(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator, b: bool) -> None

C++: protocols::calc_taskop_filters::Operator::logarithm(const bool) –> void

modify_relative_filters_pdb_names(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator) → None¶: C++: protocols::calc_taskop_filters::Operator::modify_relative_filters_pdb_names() –> void

multi_relative(*args, **kwargs)¶

Overloaded function.

multi_relative(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator) -> bool

C++: protocols::calc_taskop_filters::Operator::multi_relative() const –> bool

multi_relative(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator, m: bool) -> None

C++: protocols::calc_taskop_filters::Operator::multi_relative(const bool) –> void

name(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator) → str¶: C++: protocols::calc_taskop_filters::Operator::name() const –> std::string

negate(*args, **kwargs)¶

Overloaded function.

negate(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator, b: bool) -> None

C++: protocols::calc_taskop_filters::Operator::negate(const bool) –> void

negate(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator) -> bool

C++: protocols::calc_taskop_filters::Operator::negate() const –> bool

operation(*args, **kwargs)¶

Overloaded function.

operation(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator) -> pyrosetta.rosetta.protocols.calc_taskop_filters.Operation

C++: protocols::calc_taskop_filters::Operator::operation() const –> enum protocols::calc_taskop_filters::Operation

operation(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator, o: pyrosetta.rosetta.protocols.calc_taskop_filters.Operation) -> None

C++: protocols::calc_taskop_filters::Operator::operation(const enum protocols::calc_taskop_filters::Operation) –> void

parse_my_tag(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::calc_taskop_filters::Operator::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

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

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

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::calc_taskop_filters::Operator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

relative_pose_names(*args, **kwargs)¶

Overloaded function.

relative_pose_names(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::calc_taskop_filters::Operator::relative_pose_names() –> class utility::vector1<std::string, class std::allocator<std::string > >

relative_pose_names(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator, s: pyrosetta.rosetta.utility.vector1_std_string) -> None

C++: protocols::calc_taskop_filters::Operator::relative_pose_names(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

report(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::calc_taskop_filters::Operator::report(std::ostream &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::calc_taskop_filters::Operator::report_sm(const class core::pose::Pose &) const –> double

report_subvalues(*args, **kwargs)¶

Overloaded function.

report_subvalues(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator, report: bool) -> None

C++: protocols::calc_taskop_filters::Operator::report_subvalues(const bool) –> void

report_subvalues(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator) -> bool

C++: protocols::calc_taskop_filters::Operator::report_subvalues() const –> bool

reset_baseline(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator, pose: pyrosetta.rosetta.core.pose.Pose, attempt_read_from_checkpoint: bool) → None¶: C++: protocols::calc_taskop_filters::Operator::reset_baseline(const class core::pose::Pose &, const bool) –> void

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 std::string &) –> void

threshold(*args, **kwargs)¶

Overloaded function.

threshold(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator) -> float

goes over Sigmoid filters and resets them. Note that this is nonconst, and cannot be called from apply

C++: protocols::calc_taskop_filters::Operator::threshold() const –> double

threshold(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Operator, t: float) -> None

C++: protocols::calc_taskop_filters::Operator::threshold(const double) –> void

class pyrosetta.rosetta.protocols.calc_taskop_filters.OperatorFilterCreator¶

Bases: FilterCreator

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

create_filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.OperatorFilterCreator) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::OperatorFilterCreator::create_filter() const –> class std::shared_ptr<class protocols::filters::Filter>

keyname(self: pyrosetta.rosetta.protocols.calc_taskop_filters.OperatorFilterCreator) → str¶: C++: protocols::calc_taskop_filters::OperatorFilterCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.calc_taskop_filters.OperatorFilterCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::calc_taskop_filters::OperatorFilterCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter¶

Bases: Filter

apply(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶

Constructor with a single target residue

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

static attributes(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None¶: C++: protocols::calc_taskop_filters::RelativePoseFilter::attributes(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

baseline(*args, **kwargs)¶

Overloaded function.

baseline(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> bool

C++: protocols::calc_taskop_filters::RelativePoseFilter::baseline() const –> bool

baseline(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, b: bool) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::baseline(const bool) –> void

baseline_val(*args, **kwargs)¶

Overloaded function.

baseline_val(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> float

C++: protocols::calc_taskop_filters::RelativePoseFilter::baseline_val() const –> double

baseline_val(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, : float) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::baseline_val(const double) –> void

static class_name() → str¶: C++: protocols::calc_taskop_filters::RelativePoseFilter::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.calc_taskop_filters.RelativePoseFilter) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::RelativePoseFilter::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::calc_taskop_filters::RelativePoseFilter::compute(const class core::pose::Pose &) const –> double

copy_comments(*args, **kwargs)¶

Overloaded function.

copy_comments(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> pyrosetta.rosetta.utility.vector1_std_string

C++: protocols::calc_taskop_filters::RelativePoseFilter::copy_comments() const –> class utility::vector1<std::string, class std::allocator<std::string > >

copy_comments(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, s: pyrosetta.rosetta.utility.vector1_std_string) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::copy_comments(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

copy_stretch(*args, **kwargs)¶

Overloaded function.

copy_stretch(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> bool

C++: protocols::calc_taskop_filters::RelativePoseFilter::copy_stretch() const –> bool

copy_stretch(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, b: bool) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::copy_stretch(const bool) –> void

dump_pose_fname(*args, **kwargs)¶

Overloaded function.

dump_pose_fname(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> str

C++: protocols::calc_taskop_filters::RelativePoseFilter::dump_pose_fname() const –> std::string

dump_pose_fname(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, s: str) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::dump_pose_fname(const std::string &) –> void

filter(*args, **kwargs)¶

Overloaded function.

filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, filter: pyrosetta.rosetta.protocols.filters.Filter) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::filter(class std::shared_ptr<class protocols::filters::Filter>) –> void

filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::calc_taskop_filters::RelativePoseFilter::filter() const –> class std::shared_ptr<class protocols::filters::Filter>

filter_name(*args, **kwargs)¶

Overloaded function.

filter_name(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> str

C++: protocols::calc_taskop_filters::RelativePoseFilter::filter_name() const –> std::string

filter_name(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, s: str) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::filter_name(const std::string &) –> void

fresh_instance(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::RelativePoseFilter::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.calc_taskop_filters.RelativePoseFilter) → str¶: C++: protocols::calc_taskop_filters::RelativePoseFilter::name() const –> std::string

packing_shell(*args, **kwargs)¶

Overloaded function.

packing_shell(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, s: float) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::packing_shell(const double) –> void

packing_shell(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> float

C++: protocols::calc_taskop_filters::RelativePoseFilter::packing_shell() const –> double

parse_my_tag(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::calc_taskop_filters::RelativePoseFilter::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

pdb_name(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, pdb_name: str) → None¶: C++: protocols::calc_taskop_filters::RelativePoseFilter::pdb_name(const std::string &) –> void

pose(*args, **kwargs)¶

Overloaded function.

pose(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> pyrosetta.rosetta.core.pose.Pose

C++: protocols::calc_taskop_filters::RelativePoseFilter::pose() const –> class std::shared_ptr<class core::pose::Pose>

pose(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, p: pyrosetta.rosetta.core.pose.Pose) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::pose(class std::shared_ptr<class core::pose::Pose>) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

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

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

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::calc_taskop_filters::RelativePoseFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

relax_mover(*args, **kwargs)¶

Overloaded function.

relax_mover(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::calc_taskop_filters::RelativePoseFilter::relax_mover() const –> class std::shared_ptr<class protocols::moves::Mover>

relax_mover(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, mover: pyrosetta.rosetta.protocols.moves.Mover) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::relax_mover(const class std::shared_ptr<class protocols::moves::Mover>) –> void

report(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::calc_taskop_filters::RelativePoseFilter::report(std::ostream &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::calc_taskop_filters::RelativePoseFilter::report_sm(const class core::pose::Pose &) const –> double

rtmin(*args, **kwargs)¶

Overloaded function.

rtmin(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, b: bool) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::rtmin(const bool) –> void

rtmin(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> bool

C++: protocols::calc_taskop_filters::RelativePoseFilter::rtmin() const –> bool

score(self: pyrosetta.rosetta.protocols.filters.Filter, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::filters::Filter::score(class core::pose::Pose &) –> double

scorefxn(*args, **kwargs)¶

Overloaded function.

scorefxn(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::calc_taskop_filters::RelativePoseFilter::scorefxn() const –> class std::shared_ptr<class core::scoring::ScoreFunction>

scorefxn(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, s: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::scorefxn(const class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None¶: C++: protocols::filters::Filter::set_user_defined_name(const std::string &) –> void

symmetry_definition(*args, **kwargs)¶

Overloaded function.

symmetry_definition(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, s: str) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::symmetry_definition(const std::string &) –> void

symmetry_definition(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> str

C++: protocols::calc_taskop_filters::RelativePoseFilter::symmetry_definition() const –> std::string

thread(*args, **kwargs)¶

Overloaded function.

thread(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> bool

C++: protocols::calc_taskop_filters::RelativePoseFilter::thread() const –> bool

thread(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, t: bool) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::thread(const bool) –> void

thread_seq(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, p: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pose.Pose¶: C++: protocols::calc_taskop_filters::RelativePoseFilter::thread_seq(const class core::pose::Pose &) const –> class std::shared_ptr<class core::pose::Pose>

unbound(*args, **kwargs)¶

Overloaded function.

unbound(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter) -> bool

C++: protocols::calc_taskop_filters::RelativePoseFilter::unbound() const –> bool

unbound(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilter, b: bool) -> None

C++: protocols::calc_taskop_filters::RelativePoseFilter::unbound(const bool) –> void

class pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilterCreator¶

Bases: FilterCreator

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

create_filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilterCreator) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::RelativePoseFilterCreator::create_filter() const –> class std::shared_ptr<class protocols::filters::Filter>

keyname(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilterCreator) → str¶: C++: protocols::calc_taskop_filters::RelativePoseFilterCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RelativePoseFilterCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::calc_taskop_filters::RelativePoseFilterCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight¶

Bases: Filter

apply(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶

Constructor with a single target residue

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

static class_name() → str¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::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.calc_taskop_filters.RotamerBoltzmannWeight) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::compute(const class core::pose::Pose &) const –> double

compute_Boltzmann_weight(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, pose: pyrosetta.rosetta.core.pose.Pose, resi: int) → float¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::compute_Boltzmann_weight(const class core::pose::Pose &, const unsigned long) const –> double

compute_entropy_reduction(*args, **kwargs)¶

Overloaded function.

compute_entropy_reduction(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) -> bool

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::compute_entropy_reduction() const –> bool

compute_entropy_reduction(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, cer: bool) -> None

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::compute_entropy_reduction(const bool) –> void

compute_modified_ddG(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, pose: pyrosetta.rosetta.core.pose.Pose, out: pyrosetta.rosetta.std.ostream) → float¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::compute_modified_ddG(const class core::pose::Pose &, std::ostream &) const –> double

ddG_threshold(*args, **kwargs)¶

Overloaded function.

ddG_threshold(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) -> float

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::ddG_threshold() const –> double

ddG_threshold(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, ddG: float) -> None

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::ddG_threshold(const double) –> void

energy_reduction_factor(*args, **kwargs)¶

Overloaded function.

energy_reduction_factor(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, factor: float) -> None

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::energy_reduction_factor(const double) –> void

energy_reduction_factor(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) -> float

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::energy_reduction_factor() const –> double

first_pass_ala_scan(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.utility.vector1_unsigned_long¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::first_pass_ala_scan(const class core::pose::Pose &) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

fresh_instance(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::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

interface_interaction_energy(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, pose: pyrosetta.rosetta.core.pose.Pose, res: int) → float¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::interface_interaction_energy(const class core::pose::Pose &, const unsigned long) const –> double

name(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) → str¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::name() const –> std::string

no_modified_ddG(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, no_ddg: bool) → None¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::no_modified_ddG(const bool) –> void

parse_my_tag(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

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

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

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

rb_jump(*args, **kwargs)¶

Overloaded function.

rb_jump(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, jump: int) -> None

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::rb_jump(const unsigned long) –> void

rb_jump(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) -> int

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::rb_jump() const –> unsigned long

repack(*args, **kwargs)¶

Overloaded function.

repack(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, repack: bool) -> None

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::repack(const bool) –> void

repack(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) -> bool

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::repack() const –> bool

repacking_radius(*args, **kwargs)¶

Overloaded function.

repacking_radius(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, rad: float) -> None

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::repacking_radius(const double) –> void

repacking_radius(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) -> float

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::repacking_radius() const –> double

report(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::report(std::ostream &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::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

scorefxn(*args, **kwargs)¶

Overloaded function.

scorefxn(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::scorefxn(class std::shared_ptr<class core::scoring::ScoreFunction>) –> void

scorefxn(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) -> pyrosetta.rosetta.core.scoring.ScoreFunction

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::scorefxn() const –> class std::shared_ptr<class core::scoring::ScoreFunction>

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None¶: C++: protocols::filters::Filter::set_user_defined_name(const std::string &) –> void

skip_ala_scan(*args, **kwargs)¶

Overloaded function.

skip_ala_scan(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) -> bool

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::skip_ala_scan() const –> bool

skip_ala_scan(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, s: bool) -> None

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::skip_ala_scan(const bool) –> void

sym_dof_names(*args, **kwargs)¶

Overloaded function.

sym_dof_names(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, dof_names: str) -> None

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::sym_dof_names(const std::string &) –> void

sym_dof_names(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) -> str

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::sym_dof_names() const –> std::string

target_residues(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, target_residues_str: str) → None¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::target_residues(const std::string &) –> void

task_factory(*args, **kwargs)¶

Overloaded function.

task_factory(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) -> pyrosetta.rosetta.core.pack.task.TaskFactory

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

task_factory(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, task_factory: pyrosetta.rosetta.core.pack.task.TaskFactory) -> None

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

temperature(*args, **kwargs)¶

Overloaded function.

temperature(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) -> float

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::temperature() const –> double

temperature(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, temp: float) -> None

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::temperature(const double) –> void

threshold_probability(*args, **kwargs)¶

Overloaded function.

threshold_probability(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, aa_type: pyrosetta.rosetta.core.chemical.AA, probability: float) -> None

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::threshold_probability(const enum core::chemical::AA, const double) –> void

threshold_probability(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, aa_type: pyrosetta.rosetta.core.chemical.AA) -> float

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::threshold_probability(const enum core::chemical::AA) const –> double

type(*args, **kwargs)¶

Overloaded function.

type(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) -> str

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::type() const –> std::string

type(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, s: str) -> None

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::type(const std::string &) –> void

unbound(*args, **kwargs)¶

Overloaded function.

unbound(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) -> bool

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::unbound() const –> bool

unbound(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, u: bool) -> None

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::unbound(const bool) –> void

write2pdb(*args, **kwargs)¶

Overloaded function.

write2pdb(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight) -> bool

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::write2pdb() const –> bool

write2pdb(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, write: bool) -> None

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::write2pdb(const bool) –> void

write_to_pdb(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight, residue: int, residue_name: str, boltzmann_weight: float) → None¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight::write_to_pdb(const unsigned long, const std::string &, const double) const –> void

class pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2¶

Bases: Filter

Next-generation RotamerBoltzmannWeight filter

MAX_PROBABILITY = <ScoreType.MAX_PROBABILITY: 1>¶

MEAN_PROBABILITY = <ScoreType.MEAN_PROBABILITY: 0>¶

MIN_PROBABILITY = <ScoreType.MIN_PROBABILITY: 4>¶

MODIFIED_DDG = <ScoreType.MODIFIED_DDG: 2>¶

PROBABILITY = <ScoreType.PROBABILITY: 3>¶

class ScoreType¶

Bases: pybind11_object

Members:

MEAN_PROBABILITY

MAX_PROBABILITY

MODIFIED_DDG

PROBABILITY

MIN_PROBABILITY

MAX_PROBABILITY = <ScoreType.MAX_PROBABILITY: 1>¶

MEAN_PROBABILITY = <ScoreType.MEAN_PROBABILITY: 0>¶

MIN_PROBABILITY = <ScoreType.MIN_PROBABILITY: 4>¶

MODIFIED_DDG = <ScoreType.MODIFIED_DDG: 2>¶

PROBABILITY = <ScoreType.PROBABILITY: 3>¶

property name¶

property value¶

apply(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶

returns true if the structure passes the filter, false otherwise

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

calculator_id(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2) → str¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight2::calculator_id() const –> const std::string &

static class_name() → str¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight2::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.calc_taskop_filters.RotamerBoltzmannWeight2) → pyrosetta.rosetta.protocols.filters.Filter¶

required in the context of the parser/scripting scheme

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

fresh_instance(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2) → pyrosetta.rosetta.protocols.filters.Filter¶

required in the context of the parser/scripting scheme

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

get_name(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2) → str¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight2::get_name() 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.calc_taskop_filters.RotamerBoltzmannWeight2) → str¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight2::name() const –> std::string

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

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

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

provide_citation_info(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

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

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

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight2::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2, os: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

allows printing data to a stream

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight2::report(std::ostream &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2, pose: pyrosetta.rosetta.core.pose.Pose) → float¶

required for reporting score values

C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight2::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_energy_landscape_evaluator(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2, evaluator: protocols::toolbox::EnergyLandscapeEvaluator) → None¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight2::set_energy_landscape_evaluator(class std::shared_ptr<const class protocols::toolbox::EnergyLandscapeEvaluator>) –> void

set_residue_selector(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2, selector: pyrosetta.rosetta.core.select.residue_selector.ResidueSelector) → None¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight2::set_residue_selector(class std::shared_ptr<const class core::select::residue_selector::ResidueSelector>) –> void

set_score_type(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2, scoretype: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2.ScoreType) → None¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight2::set_score_type(const enum protocols::calc_taskop_filters::RotamerBoltzmannWeight2::ScoreType) –> void

set_scorefxn(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight2::set_scorefxn(class std::shared_ptr<const class core::scoring::ScoreFunction>) –> void

set_user_defined_name(self: pyrosetta.rosetta.protocols.filters.Filter, name: str) → None¶: C++: protocols::filters::Filter::set_user_defined_name(const std::string &) –> void

class pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2Creator¶

Bases: FilterCreator

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

create_filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2Creator) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight2Creator::create_filter() const –> class std::shared_ptr<class protocols::filters::Filter>

keyname(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2Creator) → str¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight2Creator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeight2Creator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeight2Creator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeightFilterCreator¶

Bases: FilterCreator

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

create_filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeightFilterCreator) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeightFilterCreator::create_filter() const –> class std::shared_ptr<class protocols::filters::Filter>

keyname(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeightFilterCreator) → str¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeightFilterCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.calc_taskop_filters.RotamerBoltzmannWeightFilterCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::calc_taskop_filters::RotamerBoltzmannWeightFilterCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid¶

Bases: Filter

transform the output from a regular filter into a sigmoid ranging from 0-1 according to: fx = 1/[1 + exp[ ( x - offset ) * steepness ] The function asymptotically reaches 1 at negative values and 0 at positive values. It’s 0.5 at the offset and steepness determines its slope at the offset

apply(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: protocols::calc_taskop_filters::Sigmoid::apply(const class core::pose::Pose &) const –> bool

static attributes(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None¶: C++: protocols::calc_taskop_filters::Sigmoid::attributes(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

baseline_checkpointing_filename(*args, **kwargs)¶

Overloaded function.

baseline_checkpointing_filename(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid, s: str) -> None

C++: protocols::calc_taskop_filters::Sigmoid::baseline_checkpointing_filename(const std::string &) –> void

baseline_checkpointing_filename(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid) -> str

C++: protocols::calc_taskop_filters::Sigmoid::baseline_checkpointing_filename() const –> std::string

static class_name() → str¶: C++: protocols::calc_taskop_filters::Sigmoid::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.calc_taskop_filters.Sigmoid) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::Sigmoid::clone() const –> class std::shared_ptr<class protocols::filters::Filter>

compute(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::calc_taskop_filters::Sigmoid::compute(const class core::pose::Pose &) const –> double

filter(*args, **kwargs)¶

Overloaded function.

filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid) -> pyrosetta.rosetta.protocols.filters.Filter

C++: protocols::calc_taskop_filters::Sigmoid::filter() const –> class std::shared_ptr<class protocols::filters::Filter>

filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid, f: pyrosetta.rosetta.protocols.filters.Filter) -> None

C++: protocols::calc_taskop_filters::Sigmoid::filter(class std::shared_ptr<class protocols::filters::Filter>) –> void

fresh_instance(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::Sigmoid::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.calc_taskop_filters.Sigmoid) → str¶: C++: protocols::calc_taskop_filters::Sigmoid::name() const –> std::string

negate(*args, **kwargs)¶

Overloaded function.

negate(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid) -> bool

C++: protocols::calc_taskop_filters::Sigmoid::negate() const –> bool

negate(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid, b: bool) -> None

C++: protocols::calc_taskop_filters::Sigmoid::negate(const bool) –> void

offset(*args, **kwargs)¶

Overloaded function.

offset(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid) -> float

C++: protocols::calc_taskop_filters::Sigmoid::offset() –> double

offset(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid, o: float) -> None

C++: protocols::calc_taskop_filters::Sigmoid::offset(const double) –> void

parse_my_tag(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid, tag: pyrosetta.rosetta.utility.tag.Tag, : pyrosetta.rosetta.basic.datacache.DataMap) → None¶: C++: protocols::calc_taskop_filters::Sigmoid::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.protocols.filters.Filter, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None¶

Provide citations to the passed CitationCollectionList

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

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

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::calc_taskop_filters::Sigmoid::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

report(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: protocols::calc_taskop_filters::Sigmoid::report(std::ostream &, const class core::pose::Pose &) const –> void

report_sm(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid, pose: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: protocols::calc_taskop_filters::Sigmoid::report_sm(const class core::pose::Pose &) const –> double

reset_baseline(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid, pose: pyrosetta.rosetta.core.pose.Pose, attempt_read_from_checkpoint: bool) → None¶: C++: protocols::calc_taskop_filters::Sigmoid::reset_baseline(const class core::pose::Pose &, const bool) –> void

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 std::string &) –> void

steepness(*args, **kwargs)¶

Overloaded function.

steepness(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid) -> float

C++: protocols::calc_taskop_filters::Sigmoid::steepness() const –> double

steepness(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid, s: float) -> None

C++: protocols::calc_taskop_filters::Sigmoid::steepness(const double) –> void

threshold(*args, **kwargs)¶

Overloaded function.

threshold(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid) -> float

allows within-trajectory resetting of the baseline. Notice this is nonconst, so can’t be called from apply. attempt_read_from_checkpoint should be true for MC trials > 1, but false otherwise

C++: protocols::calc_taskop_filters::Sigmoid::threshold() const –> double

threshold(self: pyrosetta.rosetta.protocols.calc_taskop_filters.Sigmoid, t: float) -> None

C++: protocols::calc_taskop_filters::Sigmoid::threshold(const double) –> void

class pyrosetta.rosetta.protocols.calc_taskop_filters.SigmoidFilterCreator¶

Bases: FilterCreator

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

create_filter(self: pyrosetta.rosetta.protocols.calc_taskop_filters.SigmoidFilterCreator) → pyrosetta.rosetta.protocols.filters.Filter¶: C++: protocols::calc_taskop_filters::SigmoidFilterCreator::create_filter() const –> class std::shared_ptr<class protocols::filters::Filter>

keyname(self: pyrosetta.rosetta.protocols.calc_taskop_filters.SigmoidFilterCreator) → str¶: C++: protocols::calc_taskop_filters::SigmoidFilterCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.calc_taskop_filters.SigmoidFilterCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::calc_taskop_filters::SigmoidFilterCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void