frag_picker

• nonlocal
• quota
• scores

Bindings for protocols::frag_picker namespace

class pyrosetta.rosetta.protocols.frag_picker.AllowPdbIdFilter

Bases: pyrosetta.rosetta.protocols.frag_picker.PdbIdChunkFilter

Accepts a chunk based on the pdb id of the source protein

If a given chunk comes from a registered pdb file then it will PASS the test. Otherwise it will be rejected

add_pdb_id(self: pyrosetta.rosetta.protocols.frag_picker.PdbIdChunkFilter, pdb_ids: str) → None

Adds a pdb id to the filter.

What that PDB id means it depends on the filter implementation

C++: protocols::frag_picker::PdbIdChunkFilter::add_pdb_id(class std::basic_string<char>) –> void

add_pdb_ids(self: pyrosetta.rosetta.protocols.frag_picker.PdbIdChunkFilter, list_of_pdb_ids: pyrosetta.rosetta.utility.vector1_std_string) → None

Adds a bunch of pdb ids to the filter

C++: protocols::frag_picker::PdbIdChunkFilter::add_pdb_ids(class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > >) –> void

assign(self: pyrosetta.rosetta.protocols.frag_picker.AllowPdbIdFilter, : pyrosetta.rosetta.protocols.frag_picker.AllowPdbIdFilter) → pyrosetta.rosetta.protocols.frag_picker.AllowPdbIdFilter

C++: protocols::frag_picker::AllowPdbIdFilter::operator=(const class protocols::frag_picker::AllowPdbIdFilter &) –> class protocols::frag_picker::AllowPdbIdFilter &

load_pdb_id_from_file(self: pyrosetta.rosetta.protocols.frag_picker.PdbIdChunkFilter, : str) → None

C++: protocols::frag_picker::PdbIdChunkFilter::load_pdb_id_from_file(class std::basic_string<char>) –> void

show_pdb_ids(self: pyrosetta.rosetta.protocols.frag_picker.PdbIdChunkFilter, out: pyrosetta.rosetta.std.ostream) → None

C++: protocols::frag_picker::PdbIdChunkFilter::show_pdb_ids(class std::basic_ostream<char> &) –> void

test_chunk(self: pyrosetta.rosetta.protocols.frag_picker.AllowPdbIdFilter, a_chunk: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → bool

say if a given chunk looks promising.

Simply if its pdb id is on a list then it will pass the test

C++: protocols::frag_picker::AllowPdbIdFilter::test_chunk(class std::shared_ptr<class protocols::frag_picker::VallChunk>) –> bool

class pyrosetta.rosetta.protocols.frag_picker.BestTotalScoreSelector

Bases: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule

selects a given number of fragments using a quota scheme

assign(self: pyrosetta.rosetta.protocols.frag_picker.BestTotalScoreSelector, : pyrosetta.rosetta.protocols.frag_picker.BestTotalScoreSelector) → pyrosetta.rosetta.protocols.frag_picker.BestTotalScoreSelector

C++: protocols::frag_picker::BestTotalScoreSelector::operator=(const class protocols::frag_picker::BestTotalScoreSelector &) –> class protocols::frag_picker::BestTotalScoreSelector &

frags_per_pos(self: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule) → int

Says how many fragments will be selected for each position in a query sequence

C++: protocols::frag_picker::FragmentSelectingRule::frags_per_pos() –> unsigned long

select_fragments(self: pyrosetta.rosetta.protocols.frag_picker.BestTotalScoreSelector, : pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t, : pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t) → None

Selects desired number of fragments from a given candidates

C++: protocols::frag_picker::BestTotalScoreSelector::select_fragments(const class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &, class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &) –> void

class pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector

Bases: pybind11_builtins.pybind11_object

TODO write collector for mixed fragment lengths

A base class for collecting fragments.

The purpose of a collector is to keep fragment candidates to the end of vall processing. Then a selector will go through all the candidates stored in a collector and select the final fragments

GrabAll collector for a possible implementation

add(self: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector, : Tuple[pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap]) → bool

Insert a fragment candidate to the container

C++: protocols::frag_picker::CandidatesCollector::add(struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >) –> bool

assign(self: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector, : pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector) → pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector

C++: protocols::frag_picker::CandidatesCollector::operator=(const class protocols::frag_picker::CandidatesCollector &) –> class protocols::frag_picker::CandidatesCollector &

clear(self: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector) → None

removes all candidates from the container

C++: protocols::frag_picker::CandidatesCollector::clear() –> void

count_candidates(*args, **kwargs)

Overloaded function.

1. count_candidates(self: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector, : int) -> int

Check how many candidates have been already collected for a given position

C++: protocols::frag_picker::CandidatesCollector::count_candidates(unsigned long) const –> unsigned long

2. count_candidates(self: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector) -> int

Check how many candidates have been already collected for all positions

C++: protocols::frag_picker::CandidatesCollector::count_candidates() const –> unsigned long

get_candidates(self: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector, position_in_query: int) → pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t

C++: protocols::frag_picker::CandidatesCollector::get_candidates(unsigned long) –> class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &

insert(self: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector, : int, : pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector) → None

inserts candidates from another collector

Candidates may or may not get inserted depending on the candidate and type of storage

C++: protocols::frag_picker::CandidatesCollector::insert(unsigned long, class std::shared_ptr<class protocols::frag_picker::CandidatesCollector>) –> void

print_report(self: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector, output: pyrosetta.rosetta.std.ostream, scoring: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreManager) → None

Describes what has been collected

C++: protocols::frag_picker::CandidatesCollector::print_report(class std::basic_ostream<char> &, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreManager>) const –> void

query_length(self: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector) → int

Check the size of query sequence that this object knows.

This is mainly to be ale to check if it is the same as in the other parts of fragment picking machinery.

C++: protocols::frag_picker::CandidatesCollector::query_length() const –> unsigned long

class pyrosetta.rosetta.protocols.frag_picker.CompareByScoreCombination

Bases: pyrosetta.rosetta.protocols.frag_picker.FragmentComparatorBase

comparator based on the linear combination of some score components

returns true if first pair has lower weighted score than the second one

assign(self: pyrosetta.rosetta.protocols.frag_picker.CompareByScoreCombination, : pyrosetta.rosetta.protocols.frag_picker.CompareByScoreCombination) → pyrosetta.rosetta.protocols.frag_picker.CompareByScoreCombination

C++: protocols::frag_picker::CompareByScoreCombination::operator=(const class protocols::frag_picker::CompareByScoreCombination &) –> class protocols::frag_picker::CompareByScoreCombination &

class pyrosetta.rosetta.protocols.frag_picker.CompareQueryPosition

Bases: pyrosetta.rosetta.protocols.frag_picker.FragmentComparatorBase

comparator based on a sequence position in a query

assign(self: pyrosetta.rosetta.protocols.frag_picker.CompareQueryPosition, : pyrosetta.rosetta.protocols.frag_picker.CompareQueryPosition) → pyrosetta.rosetta.protocols.frag_picker.CompareQueryPosition

C++: protocols::frag_picker::CompareQueryPosition::operator=(const class protocols::frag_picker::CompareQueryPosition &) –> class protocols::frag_picker::CompareQueryPosition &

class pyrosetta.rosetta.protocols.frag_picker.CompareScoreComponent

Bases: pyrosetta.rosetta.protocols.frag_picker.FragmentComparatorBase

comparator based on one of the score components calculated for fragments

returns true if first pair has lower score component than the second one

assign(self: pyrosetta.rosetta.protocols.frag_picker.CompareScoreComponent, : pyrosetta.rosetta.protocols.frag_picker.CompareScoreComponent) → pyrosetta.rosetta.protocols.frag_picker.CompareScoreComponent

C++: protocols::frag_picker::CompareScoreComponent::operator=(const class protocols::frag_picker::CompareScoreComponent &) –> class protocols::frag_picker::CompareScoreComponent &

class pyrosetta.rosetta.protocols.frag_picker.CompareTotalScore

Bases: pyrosetta.rosetta.protocols.frag_picker.FragmentComparatorBase

comparator based on the total score of fragments

returns true if first pair has lower total score than the second one

assign(self: pyrosetta.rosetta.protocols.frag_picker.CompareTotalScore, : pyrosetta.rosetta.protocols.frag_picker.CompareTotalScore) → pyrosetta.rosetta.protocols.frag_picker.CompareTotalScore

C++: protocols::frag_picker::CompareTotalScore::operator=(const class protocols::frag_picker::CompareTotalScore &) –> class protocols::frag_picker::CompareTotalScore &

class pyrosetta.rosetta.protocols.frag_picker.CompositeFragmentSelector

Bases: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule

selects fragments by running several selectors

add_selector(self: pyrosetta.rosetta.protocols.frag_picker.CompositeFragmentSelector, new_selector: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule) → None

C++: protocols::frag_picker::CompositeFragmentSelector::add_selector(class std::shared_ptr<class protocols::frag_picker::FragmentSelectingRule>) –> void

assign(self: pyrosetta.rosetta.protocols.frag_picker.CompositeFragmentSelector, : pyrosetta.rosetta.protocols.frag_picker.CompositeFragmentSelector) → pyrosetta.rosetta.protocols.frag_picker.CompositeFragmentSelector

C++: protocols::frag_picker::CompositeFragmentSelector::operator=(const class protocols::frag_picker::CompositeFragmentSelector &) –> class protocols::frag_picker::CompositeFragmentSelector &

frags_per_pos(self: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule) → int

Says how many fragments will be selected for each position in a query sequence

C++: protocols::frag_picker::FragmentSelectingRule::frags_per_pos() –> unsigned long

select_fragments(self: pyrosetta.rosetta.protocols.frag_picker.CompositeFragmentSelector, : pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t, : pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t) → None

Selects desired number of fragments from a given set of candidates

C++: protocols::frag_picker::CompositeFragmentSelector::select_fragments(const class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &, class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &) –> void

class pyrosetta.rosetta.protocols.frag_picker.ContactType

Bases: pybind11_builtins.pybind11_object

Members:

CA

CB

CEN

UNK

num_contact_types

class pyrosetta.rosetta.protocols.frag_picker.CustomScoreSelector

Bases: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule

selects a given number of fragments using a quota scheme

assign(self: pyrosetta.rosetta.protocols.frag_picker.CustomScoreSelector, : pyrosetta.rosetta.protocols.frag_picker.CustomScoreSelector) → pyrosetta.rosetta.protocols.frag_picker.CustomScoreSelector

C++: protocols::frag_picker::CustomScoreSelector::operator=(const class protocols::frag_picker::CustomScoreSelector &) –> class protocols::frag_picker::CustomScoreSelector &

frags_per_pos(self: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule) → int

Says how many fragments will be selected for each position in a query sequence

C++: protocols::frag_picker::FragmentSelectingRule::frags_per_pos() –> unsigned long

select_fragments(self: pyrosetta.rosetta.protocols.frag_picker.CustomScoreSelector, : pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t, : pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t) → None

Selects desired number of fragments from a given candidates

C++: protocols::frag_picker::CustomScoreSelector::select_fragments(const class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &, class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &) –> void

class pyrosetta.rosetta.protocols.frag_picker.DenyPdbIdFilter

Bases: pyrosetta.rosetta.protocols.frag_picker.PdbIdChunkFilter

Denies a chunk based on the pdb id of the source protein

If a given chunk comes from a registered pdb file then it will FAIL the test. Otherwise it will be accepted

add_pdb_id(self: pyrosetta.rosetta.protocols.frag_picker.PdbIdChunkFilter, pdb_ids: str) → None

Adds a pdb id to the filter.

What that PDB id means it depends on the filter implementation

C++: protocols::frag_picker::PdbIdChunkFilter::add_pdb_id(class std::basic_string<char>) –> void

add_pdb_ids(self: pyrosetta.rosetta.protocols.frag_picker.PdbIdChunkFilter, list_of_pdb_ids: pyrosetta.rosetta.utility.vector1_std_string) → None

Adds a bunch of pdb ids to the filter

C++: protocols::frag_picker::PdbIdChunkFilter::add_pdb_ids(class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > >) –> void

assign(self: pyrosetta.rosetta.protocols.frag_picker.DenyPdbIdFilter, : pyrosetta.rosetta.protocols.frag_picker.DenyPdbIdFilter) → pyrosetta.rosetta.protocols.frag_picker.DenyPdbIdFilter

C++: protocols::frag_picker::DenyPdbIdFilter::operator=(const class protocols::frag_picker::DenyPdbIdFilter &) –> class protocols::frag_picker::DenyPdbIdFilter &

load_pdb_id_from_file(self: pyrosetta.rosetta.protocols.frag_picker.PdbIdChunkFilter, : str) → None

C++: protocols::frag_picker::PdbIdChunkFilter::load_pdb_id_from_file(class std::basic_string<char>) –> void

show_pdb_ids(self: pyrosetta.rosetta.protocols.frag_picker.PdbIdChunkFilter, out: pyrosetta.rosetta.std.ostream) → None

C++: protocols::frag_picker::PdbIdChunkFilter::show_pdb_ids(class std::basic_ostream<char> &) –> void

test_chunk(self: pyrosetta.rosetta.protocols.frag_picker.DenyPdbIdFilter, a_chunk: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → bool

say if a given chunk looks promising.

Simply if its pdb id is on a list then it will be rejected

C++: protocols::frag_picker::DenyPdbIdFilter::test_chunk(class std::shared_ptr<class protocols::frag_picker::VallChunk>) –> bool

class pyrosetta.rosetta.protocols.frag_picker.DiversifyCrmsdByClustering

Bases: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule

selects fragments by running several selectors

assign(self: pyrosetta.rosetta.protocols.frag_picker.DiversifyCrmsdByClustering, : pyrosetta.rosetta.protocols.frag_picker.DiversifyCrmsdByClustering) → pyrosetta.rosetta.protocols.frag_picker.DiversifyCrmsdByClustering

C++: protocols::frag_picker::DiversifyCrmsdByClustering::operator=(const class protocols::frag_picker::DiversifyCrmsdByClustering &) –> class protocols::frag_picker::DiversifyCrmsdByClustering &

frags_per_pos(self: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule) → int

Says how many fragments will be selected for each position in a query sequence

C++: protocols::frag_picker::FragmentSelectingRule::frags_per_pos() –> unsigned long

select_fragments(self: pyrosetta.rosetta.protocols.frag_picker.DiversifyCrmsdByClustering, : pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t, : pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t) → None

Selects desired number of fragments from a given set of candidates

C++: protocols::frag_picker::DiversifyCrmsdByClustering::select_fragments(const class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &, class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &) –> void

class pyrosetta.rosetta.protocols.frag_picker.DiversifyCrmsdSelector

Bases: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule

selects fragments by running several selectors

assign(self: pyrosetta.rosetta.protocols.frag_picker.DiversifyCrmsdSelector, : pyrosetta.rosetta.protocols.frag_picker.DiversifyCrmsdSelector) → pyrosetta.rosetta.protocols.frag_picker.DiversifyCrmsdSelector

C++: protocols::frag_picker::DiversifyCrmsdSelector::operator=(const class protocols::frag_picker::DiversifyCrmsdSelector &) –> class protocols::frag_picker::DiversifyCrmsdSelector &

frags_per_pos(self: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule) → int

Says how many fragments will be selected for each position in a query sequence

C++: protocols::frag_picker::FragmentSelectingRule::frags_per_pos() –> unsigned long

select_fragments(self: pyrosetta.rosetta.protocols.frag_picker.DiversifyCrmsdSelector, : pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t, : pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t) → None

Selects desired number of fragments from a given set of candidates

C++: protocols::frag_picker::DiversifyCrmsdSelector::select_fragments(const class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &, class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &) –> void

class pyrosetta.rosetta.protocols.frag_picker.DiversifyDihedralsSelector

Bases: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule

selects fragments by running several selectors

assign(self: pyrosetta.rosetta.protocols.frag_picker.DiversifyDihedralsSelector, : pyrosetta.rosetta.protocols.frag_picker.DiversifyDihedralsSelector) → pyrosetta.rosetta.protocols.frag_picker.DiversifyDihedralsSelector

C++: protocols::frag_picker::DiversifyDihedralsSelector::operator=(const class protocols::frag_picker::DiversifyDihedralsSelector &) –> class protocols::frag_picker::DiversifyDihedralsSelector &

dihedral_rmsd(self: pyrosetta.rosetta.protocols.frag_picker.DiversifyDihedralsSelector, : pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, : pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → float

C++: protocols::frag_picker::DiversifyDihedralsSelector::dihedral_rmsd(class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>) –> double

frags_per_pos(self: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule) → int

Says how many fragments will be selected for each position in a query sequence

C++: protocols::frag_picker::FragmentSelectingRule::frags_per_pos() –> unsigned long

select_fragments(self: pyrosetta.rosetta.protocols.frag_picker.DiversifyDihedralsSelector, : pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t, : pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t) → None

Selects desired number of fragments from a given set of candidates

C++: protocols::frag_picker::DiversifyDihedralsSelector::select_fragments(const class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &, class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &) –> void

class pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate

Bases: pybind11_builtins.pybind11_object

Vector candidate says which X-mer from vall fits to a query sequence

Scores for a given fragment are stored separately in a FragmentScoreMap object Therefore fragment containers hold std::pair<FragmentCandidateOP,FragmentScoreMapOP>

assign(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, : pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate

C++: protocols::frag_picker::FragmentCandidate::operator=(const class protocols::frag_picker::FragmentCandidate &) –> class protocols::frag_picker::FragmentCandidate &

get_chain_id(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → str

returns a chain id of a protein from which the fragment has been extracted

C++: protocols::frag_picker::FragmentCandidate::get_chain_id() const –> char

get_chunk(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → pyrosetta.rosetta.protocols.frag_picker.VallChunk

returns a pointer to the original chunk from vall the fragment comes from

C++: protocols::frag_picker::FragmentCandidate::get_chunk() const –> class std::shared_ptr<class protocols::frag_picker::VallChunk>

get_first_index_in_query(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → int

returns the index of a very first residue in a query sequence that is covered by this fragment

C++: protocols::frag_picker::FragmentCandidate::get_first_index_in_query() const –> unsigned long

get_first_index_in_vall(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → int

returns the index of a very first residue in a Vall chunk that is covered by this fragment

C++: protocols::frag_picker::FragmentCandidate::get_first_index_in_vall() const –> unsigned long

get_frag_data(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → pyrosetta.rosetta.core.fragment.FragData

C++: protocols::frag_picker::FragmentCandidate::get_frag_data() –> class std::shared_ptr<class core::fragment::FragData>

get_length(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → int

returns the length of this fragment

C++: protocols::frag_picker::FragmentCandidate::get_length() const –> unsigned long

get_middle_residue(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → pyrosetta.rosetta.protocols.frag_picker.VallResidue

returns the middle residue of this fragment candidate

C++: protocols::frag_picker::FragmentCandidate::get_middle_residue() const –> class std::shared_ptr<class protocols::frag_picker::VallResidue>

get_middle_ss(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → str

returns secondary structure assigned to the middle residue of this fragment candidate

secondary structure of the middle residue of this fragment, as extracted from Vall data

C++: protocols::frag_picker::FragmentCandidate::get_middle_ss() const –> char

get_pdb_id(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → str

returns a PDB id of a protein from which the fragment has been extracted

C++: protocols::frag_picker::FragmentCandidate::get_pdb_id() const –> std::string

get_pool_name(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → str

C++: protocols::frag_picker::FragmentCandidate::get_pool_name() –> std::string

get_query_middle_res_id(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → int

returns a query index of a middle residue in this fragment

a position of the middle residue of this fragment in the query sequence

C++: protocols::frag_picker::FragmentCandidate::get_query_middle_res_id() –> unsigned long

get_residue(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, whichOne: int) → pyrosetta.rosetta.protocols.frag_picker.VallResidue

returns a given residue from this fragment

the irgument is in the range [1,fragmentLength]

C++: protocols::frag_picker::FragmentCandidate::get_residue(unsigned long) const –> class std::shared_ptr<class protocols::frag_picker::VallResidue>

get_vall_middle_res_id(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → int

returns a vall index of a middle residue in this fragment

a position of the middle residue of this fragment in the vall sequence

C++: protocols::frag_picker::FragmentCandidate::get_vall_middle_res_id() –> unsigned long

key(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → int

returns an integer key identifying a fragment

C++: protocols::frag_picker::FragmentCandidate::key() const –> unsigned long

output_silent(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, sfd: pyrosetta.rosetta.core.io.silent.SilentFileData, sequence: str, silent_file_name: str, tag: str, sc: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap, ms: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreManager) → None

Prints fragment to silent struct

C++: protocols::frag_picker::FragmentCandidate::output_silent(class core::io::silent::SilentFileData &, const class std::basic_string<char> &, const class std::basic_string<char> &, const class std::basic_string<char> &, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreManager>) –> void

print_fragment(*args, **kwargs)

Overloaded function.

1. print_fragment(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, out: pyrosetta.rosetta.std.ostream) -> None
2. print_fragment(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, out: pyrosetta.rosetta.std.ostream, sc: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap) -> None
3. print_fragment(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, out: pyrosetta.rosetta.std.ostream, sc: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap, ms: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreManager) -> None

Prints fragment data, the output can be directly loaded to minirosetta

C++: protocols::frag_picker::FragmentCandidate::print_fragment(class std::basic_ostream<char> &, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreManager>) –> void

print_fragment_index(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, out: pyrosetta.rosetta.std.ostream, vall_index_database_exists: bool) → None

C++: protocols::frag_picker::FragmentCandidate::print_fragment_index(class std::basic_ostream<char> &, bool) –> void

print_fragment_seq(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, out: pyrosetta.rosetta.std.ostream) → None

Prints fragment sequence, used for generating structure based sequence profiles

C++: protocols::frag_picker::FragmentCandidate::print_fragment_seq(class std::basic_ostream<char> &) –> void

same_chain(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, fr: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → bool

C++: protocols::frag_picker::FragmentCandidate::same_chain(class std::shared_ptr<const class protocols::frag_picker::FragmentCandidate>) –> bool

sequence(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate) → str

creates a new string object that contains a sequence of this fragment

C++: protocols::frag_picker::FragmentCandidate::sequence() –> std::string

set_pool_name(self: pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pool_name: str) → None

C++: protocols::frag_picker::FragmentCandidate::set_pool_name(const class std::basic_string<char> &) –> void

class pyrosetta.rosetta.protocols.frag_picker.FragmentPicker

Bases: pybind11_builtins.pybind11_object

The core of the fragment picking machinery

FragmentPicker class does:

• know about query data: sequence, sequence profile, secondary structure. All other query data must be loaded directly to the relevant scoring methods
• provide slots for ‘plugable’ parts of the machinery, like chunk filters, scoring methods and so on.
• pick fragments

add_chunk_filter(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, filter: pyrosetta.rosetta.protocols.frag_picker.VallChunkFilter) → None

adds a chunk filter that will be used to screen chunks before they are cut into fragments

C++: protocols::frag_picker::FragmentPicker::add_chunk_filter(class std::shared_ptr<class protocols::frag_picker::VallChunkFilter>) –> void

add_query_ss(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, : str, : str) → None

Sets the query secondary structure

C++: protocols::frag_picker::FragmentPicker::add_query_ss(class std::basic_string<char>, class std::basic_string<char>) –> void

add_scoring_method(*args, **kwargs)

Overloaded function.

1. add_scoring_method(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, scoring_term: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoringMethod, weight: float) -> None
2. add_scoring_method(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, scoring_term: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoringMethod, weight: float, index: int) -> None

adds a new scoring method to the scoring scheme

C++: protocols::frag_picker::FragmentPicker::add_scoring_method(class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoringMethod>, double, unsigned long) –> void

assign(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, : pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → pyrosetta.rosetta.protocols.frag_picker.FragmentPicker

C++: protocols::frag_picker::FragmentPicker::operator=(const class protocols::frag_picker::FragmentPicker &) –> class protocols::frag_picker::FragmentPicker &

bounded_protocol(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → None

Picks fragments and saves them into proper files - uses bounded queue.

This protocol scores all vall data against all query positions and keeps a limited number of candidates per position using a bounded queue. When all candidates for all positions are scored, it selects final fragments.

C++: protocols::frag_picker::FragmentPicker::bounded_protocol() –> void

count_query_ss(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → int

Sets the query secondary structure

C++: protocols::frag_picker::FragmentPicker::count_query_ss() –> unsigned long

create_scores(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, file_name: str) → None

Creates scoring methods from score file, same as using

frags::scoring::config command-line option

C++: protocols::frag_picker::FragmentPicker::create_scores(class std::basic_string<char>) –> void

fragment_contacts(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, fragment_size: int, fragment_set: pyrosetta.rosetta.utility.vector1_utility_vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_std_allocator_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t) → None

C++: protocols::frag_picker::FragmentPicker::fragment_contacts(const unsigned long, const class utility::vector1<class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > >, class std::allocator<class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > > > &) –> void

get_candidates_collector(*args, **kwargs)

Overloaded function.

1. get_candidates_collector(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, frag_size: int) -> pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector
2. get_candidates_collector(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, frag_size: int, index: int) -> pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector

returns a pointer to the candidates collector currently used

one may need this instance to access the candidates that have been found by the picker

C++: protocols::frag_picker::FragmentPicker::get_candidates_collector(unsigned long, unsigned long) –> class std::shared_ptr<class protocols::frag_picker::CandidatesCollector>

get_final_fragments(*args, **kwargs)

Overloaded function.

1. get_final_fragments(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, qPos: int, frag_size: int, out: pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t) -> None

C++: protocols::frag_picker::FragmentPicker::get_final_fragments(unsigned long, unsigned long, class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &) –> void

2. get_final_fragments(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, qPos: int, out: pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t) -> None

C++: protocols::frag_picker::FragmentPicker::get_final_fragments(unsigned long, class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &) –> void

get_frag_sizes(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → pyrosetta.rosetta.utility.vector1_unsigned_long

getter for frag_sizes_

C++: protocols::frag_picker::FragmentPicker::get_frag_sizes() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

get_n_candidates(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → int

Gets n_candidates_

C++: protocols::frag_picker::FragmentPicker::get_n_candidates() const –> unsigned long

get_n_frags(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → int

Gets n_frags_

C++: protocols::frag_picker::FragmentPicker::get_n_frags() const –> unsigned long

get_picked_positions(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → pyrosetta.rosetta.utility.vector1_unsigned_long

returns vector of picked positions

C++: protocols::frag_picker::FragmentPicker::get_picked_positions() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

get_query_phi_prediction(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → pyrosetta.rosetta.utility.vector1_double

Returns the phi prediction

C++: protocols::frag_picker::FragmentPicker::get_query_phi_prediction() –> class utility::vector1<double, class std::allocator<double> > &

get_query_phi_prediction_conf(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → pyrosetta.rosetta.utility.vector1_double

Returns the phi prediction confidence

C++: protocols::frag_picker::FragmentPicker::get_query_phi_prediction_conf() –> class utility::vector1<double, class std::allocator<double> > &

get_query_psi_prediction(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → pyrosetta.rosetta.utility.vector1_double

Returns the psi prediction

C++: protocols::frag_picker::FragmentPicker::get_query_psi_prediction() –> class utility::vector1<double, class std::allocator<double> > &

get_query_psi_prediction_conf(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → pyrosetta.rosetta.utility.vector1_double

Returns the psi prediction confidence

C++: protocols::frag_picker::FragmentPicker::get_query_psi_prediction_conf() –> class utility::vector1<double, class std::allocator<double> > &

get_query_residue_depth(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → pyrosetta.rosetta.utility.vector1_double

Returns residue depth values

C++: protocols::frag_picker::FragmentPicker::get_query_residue_depth() –> class utility::vector1<double, class std::allocator<double> > &

get_query_sa_prediction(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → pyrosetta.rosetta.utility.vector1_double

Returns the solvent accessibility prediction

C++: protocols::frag_picker::FragmentPicker::get_query_sa_prediction() –> class utility::vector1<double, class std::allocator<double> > &

get_query_seq(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → pyrosetta.rosetta.core.sequence.SequenceProfile

C++: protocols::frag_picker::FragmentPicker::get_query_seq() –> class std::shared_ptr<class core::sequence::SequenceProfile>

get_query_seq_string(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → str

Returns the sequence we are picking fragments for (as a string)

C++: protocols::frag_picker::FragmentPicker::get_query_seq_string() –> std::string &

get_query_ss(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, prediction_name: str) → pyrosetta.rosetta.core.fragment.SecondaryStructure

Returns the query secondary structure as a SecondaryStructure object

C++: protocols::frag_picker::FragmentPicker::get_query_ss(class std::basic_string<char>) –> class std::shared_ptr<class core::fragment::SecondaryStructure>

get_query_ss_string(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, prediction_name: str) → str

Returns the query secondary structure as a string

C++: protocols::frag_picker::FragmentPicker::get_query_ss_string(class std::basic_string<char>) –> std::string &

get_score_manager(*args, **kwargs)

Overloaded function.

1. get_score_manager(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) -> pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreManager
2. get_score_manager(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, index: int) -> pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreManager

returns a pointer to a scoring manager

C++: protocols::frag_picker::FragmentPicker::get_score_manager(unsigned long) –> class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreManager>

get_self_ptr(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → pyrosetta.rosetta.protocols.frag_picker.FragmentPicker

C++: protocols::frag_picker::FragmentPicker::get_self_ptr() –> class std::shared_ptr<class protocols::frag_picker::FragmentPicker>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → pyrosetta.rosetta.std.weak_ptr_protocols_frag_picker_FragmentPicker_t

C++: protocols::frag_picker::FragmentPicker::get_self_weak_ptr() –> class std::weak_ptr<class protocols::frag_picker::FragmentPicker>

get_vall(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → pyrosetta.rosetta.protocols.frag_picker.VallProvider

a pointer to Vall provider

C++: protocols::frag_picker::FragmentPicker::get_vall() –> class std::shared_ptr<class protocols::frag_picker::VallProvider>

is_valid_chunk(*args, **kwargs)

Overloaded function.

1. is_valid_chunk(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, chunk: pyrosetta.rosetta.protocols.frag_picker.VallChunk) -> bool

C++: protocols::frag_picker::FragmentPicker::is_valid_chunk(class std::shared_ptr<class protocols::frag_picker::VallChunk>) –> bool

2. is_valid_chunk(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, frag_len: int, chunk: pyrosetta.rosetta.protocols.frag_picker.VallChunk) -> bool

C++: protocols::frag_picker::FragmentPicker::is_valid_chunk(const unsigned long, class std::shared_ptr<class protocols::frag_picker::VallChunk>) –> bool

keep_all_protocol(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → None

Picks fragments and saves them into proper files - independently for each query position.

This protocol scores all vall data against a given position and keeps all the candidates unless they fail an energy filter When all candidates for a positions are scored, it selects fragments for the position and proceeds to the next position. Bounded queue is not used

C++: protocols::frag_picker::FragmentPicker::keep_all_protocol() –> void

max_frag_len(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → int

How long is the longest fragment?

C++: protocols::frag_picker::FragmentPicker::max_frag_len() –> unsigned long

nonlocal_pairs(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, fragment_size: int, fragment_set: pyrosetta.rosetta.utility.vector1_utility_vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_std_allocator_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t) → None

C++: protocols::frag_picker::FragmentPicker::nonlocal_pairs(const unsigned long, const class utility::vector1<class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > >, class std::allocator<class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > > > &) –> void

output_fragments(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, fragment_size: int, final_fragments: pyrosetta.rosetta.utility.vector1_utility_vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_std_allocator_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t) → None

C++: protocols::frag_picker::FragmentPicker::output_fragments(const unsigned long, const class utility::vector1<class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > >, class std::allocator<class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > > > &) –> void

parse_command_line(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → None

C++: protocols::frag_picker::FragmentPicker::parse_command_line() –> void

parse_quota_command_line(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → None

C++: protocols::frag_picker::FragmentPicker::parse_quota_command_line() –> void

pick_candidates(*args, **kwargs)

Overloaded function.

1. pick_candidates(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) -> None

C++: protocols::frag_picker::FragmentPicker::pick_candidates() –> void

2. pick_candidates(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, i_pos: int, frag_len: int) -> None

C++: protocols::frag_picker::FragmentPicker::pick_candidates(unsigned long, unsigned long) –> void

pick_chunk_candidates(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, chunks: pyrosetta.rosetta.utility.vector1_std_shared_ptr_protocols_frag_picker_VallChunk_t, index: int) → None

multi-threaded task

C++: protocols::frag_picker::FragmentPicker::pick_chunk_candidates(const class utility::vector1<class std::shared_ptr<class protocols::frag_picker::VallChunk>, class std::allocator<class std::shared_ptr<class protocols::frag_picker::VallChunk> > > &, const unsigned long &) –> void

quota_protocol(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → None

C++: protocols::frag_picker::FragmentPicker::quota_protocol() –> void

read_depth(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, file_name: str) → None

Reads DEPTH residue depth values

C++: protocols::frag_picker::FragmentPicker::read_depth(const class std::basic_string<char> &) –> void

read_psipred_ss2(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, : str, : str) → None

Reads query secondary structure prediction from a PsiPred file

C++: protocols::frag_picker::FragmentPicker::read_psipred_ss2(const class std::basic_string<char> &, class std::basic_string<char>) –> void

read_spine_x(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, file_name: str) → None

Reads spine-x phi, psi, and solvent accessibility predictions

C++: protocols::frag_picker::FragmentPicker::read_spine_x(const class std::basic_string<char> &) –> void

read_ss_file(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, : str, : str) → None

Identifies if the ss file is psipred or talos, calls appropriate reader

C++: protocols::frag_picker::FragmentPicker::read_ss_file(const class std::basic_string<char> &, class std::basic_string<char>) –> void

read_ss_files(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, sec_str_input: pyrosetta.rosetta.utility.vector1_std_string) → None

Reads a bunch of ss predicitons from files and plugs them into the picker

C++: protocols::frag_picker::FragmentPicker::read_ss_files(class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > >) –> void

read_talos_ss(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, : str, : str) → None

Reads query secondary structure prediction from a Talos+ file

C++: protocols::frag_picker::FragmentPicker::read_talos_ss(const class std::basic_string<char> &, class std::basic_string<char>) –> void

read_vall(*args, **kwargs)

Overloaded function.

1. read_vall(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, fn: str) -> None

reads a vall file

C++: protocols::frag_picker::FragmentPicker::read_vall(const class std::basic_string<char> &) –> void

2. read_vall(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, fns: pyrosetta.rosetta.utility.vector1_std_string) -> None

C++: protocols::frag_picker::FragmentPicker::read_vall(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> void

save_candidates(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → None

C++: protocols::frag_picker::FragmentPicker::save_candidates() –> void

save_fragments(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → None

C++: protocols::frag_picker::FragmentPicker::save_fragments() –> void

set_candidates_collector(*args, **kwargs)

Overloaded function.

1. set_candidates_collector(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, frag_size: int, sink: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector) -> None
2. set_candidates_collector(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, frag_size: int, sink: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector, index: int) -> None

sets a collector where fragment candidates will be kept until final selection

C++: protocols::frag_picker::FragmentPicker::set_candidates_collector(unsigned long, class std::shared_ptr<class protocols::frag_picker::CandidatesCollector>, unsigned long) –> void

set_frag_sizes(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, size: pyrosetta.rosetta.utility.vector1_unsigned_long, clear: bool) → None

Lets you set frag sizes outside the command line

C++: protocols::frag_picker::FragmentPicker::set_frag_sizes(class utility::vector1<unsigned long, class std::allocator<unsigned long> >, bool) –> void

set_n_candidates(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, n_candidates: int) → None

Sets n_candidates_

C++: protocols::frag_picker::FragmentPicker::set_n_candidates(unsigned long) –> void

set_n_frags(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, n_frags: int) → None

Sets n_frags_

C++: protocols::frag_picker::FragmentPicker::set_n_frags(unsigned long) –> void

set_picked_positions(*args, **kwargs)

Overloaded function.

1. set_picked_positions(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, : int, : int) -> None

Asks the picker to pick fragments from a given range in a query sequence

C++: protocols::frag_picker::FragmentPicker::set_picked_positions(unsigned long, unsigned long) –> void

2. set_picked_positions(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, : pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

Asks the picker to pick fragments for given positions in a query sequence

C++: protocols::frag_picker::FragmentPicker::set_picked_positions(class utility::vector1<unsigned long, class std::allocator<unsigned long> >) –> void

set_query_phi(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, query_phi: pyrosetta.rosetta.utility.vector1_double) → None

Sets the query phi angles

Directly sets the query phi angles instead of reading it from a file

C++: protocols::frag_picker::FragmentPicker::set_query_phi(class utility::vector1<double, class std::allocator<double> > &) –> void

set_query_phi_conf(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, query_phi_conf: pyrosetta.rosetta.utility.vector1_double) → None

Sets the query phi angle confidence

Directly sets the query phi angle confidence instead of reading it from a file

C++: protocols::frag_picker::FragmentPicker::set_query_phi_conf(class utility::vector1<double, class std::allocator<double> > &) –> void

set_query_profile(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, profile: pyrosetta.rosetta.core.sequence.SequenceProfile) → None

Sets the sequence object we are picking fragments for

C++: protocols::frag_picker::FragmentPicker::set_query_profile(class std::shared_ptr<class core::sequence::SequenceProfile>) –> void

set_query_psi(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, query_psi: pyrosetta.rosetta.utility.vector1_double) → None

Sets the query psi angles

Directly sets the query psi angles isntead of reading it from a file

C++: protocols::frag_picker::FragmentPicker::set_query_psi(class utility::vector1<double, class std::allocator<double> > &) –> void

set_query_psi_conf(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, query_psi_conf: pyrosetta.rosetta.utility.vector1_double) → None

Sets the query psi angle confidence

Directly sets the query psi angle confidence instead of reading it form a file

C++: protocols::frag_picker::FragmentPicker::set_query_psi_conf(class utility::vector1<double, class std::allocator<double> > &) –> void

set_query_sa(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, query_sa: pyrosetta.rosetta.utility.vector1_double) → None

Sets the query surface area

Directly sets the query surface area instead of reading it from a file

C++: protocols::frag_picker::FragmentPicker::set_query_sa(class utility::vector1<double, class std::allocator<double> > &) –> void

set_query_seq(*args, **kwargs)

Overloaded function.

1. set_query_seq(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, query_sequence: pyrosetta.rosetta.core.sequence.SequenceProfile) -> None

sets the query sequence

Well, it is a sequence profile, but the sequence can be extracted from it

C++: protocols::frag_picker::FragmentPicker::set_query_seq(class std::shared_ptr<class core::sequence::SequenceProfile>) –> void

2. set_query_seq(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, query_sequence: str) -> None

sets the query sequence

C++: protocols::frag_picker::FragmentPicker::set_query_seq(class std::basic_string<char> &) –> void

set_selector(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, selector: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule) → None

Sets selector_

C++: protocols::frag_picker::FragmentPicker::set_selector(class std::shared_ptr<class protocols::frag_picker::FragmentSelectingRule>) –> void

set_up_quota_nnmake_style(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → None

C++: protocols::frag_picker::FragmentPicker::set_up_quota_nnmake_style() –> void

set_up_ss_abego_quota(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → None

C++: protocols::frag_picker::FragmentPicker::set_up_ss_abego_quota() –> void

set_vall(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, vall_chunks: pyrosetta.rosetta.protocols.frag_picker.VallProvider) → None

sets vall data

C++: protocols::frag_picker::FragmentPicker::set_vall(class std::shared_ptr<class protocols::frag_picker::VallProvider>) –> void

show_scoring_methods(*args, **kwargs)

Overloaded function.

1. show_scoring_methods(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, out: pyrosetta.rosetta.std.ostream) -> None
2. show_scoring_methods(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, out: pyrosetta.rosetta.std.ostream, index: int) -> None

C++: protocols::frag_picker::FragmentPicker::show_scoring_methods(class std::basic_ostream<char> &, unsigned long) –> void

size_of_query(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → int

C++: protocols::frag_picker::FragmentPicker::size_of_query() –> unsigned long

total_score(*args, **kwargs)

Overloaded function.

1. total_score(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, f: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap) -> float
2. total_score(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, f: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap, index: int) -> float

Calculates total score for a given vector of small scores

(FragmentScoreMap object pointer)

FragmentScoreManager that is stored inside the picker is used for this calculation. It particular it provides weights

C++: protocols::frag_picker::FragmentPicker::total_score(class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap>, unsigned long) –> double

class pyrosetta.rosetta.protocols.frag_picker.FragmentScoreFilter

Bases: pyrosetta.rosetta.protocols.filters.Filter

–brief–

apply(self: pyrosetta.rosetta.protocols.frag_picker.FragmentScoreFilter, pose: pyrosetta.rosetta.core.pose.Pose) → bool

returns true if the structure passes the filter, false otherwise

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

class_name() → str

C++: protocols::frag_picker::FragmentScoreFilter::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.frag_picker.FragmentScoreFilter) → pyrosetta.rosetta.protocols.filters.Filter

required in the context of the parser/scripting scheme

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

compute(self: pyrosetta.rosetta.protocols.frag_picker.FragmentScoreFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: protocols::frag_picker::FragmentScoreFilter::compute(const class core::pose::Pose) const –> double

fresh_instance(self: pyrosetta.rosetta.protocols.frag_picker.FragmentScoreFilter) → pyrosetta.rosetta.protocols.filters.Filter

required in the context of the parser/scripting scheme

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

get_result(self: pyrosetta.rosetta.protocols.frag_picker.FragmentScoreFilter, : pyrosetta.rosetta.utility.vector1_double) → float

C++: protocols::frag_picker::FragmentScoreFilter::get_result(class utility::vector1<double, class std::allocator<double> >) const –> 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.frag_picker.FragmentScoreFilter) → str

C++: protocols::frag_picker::FragmentScoreFilter::name() const –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.frag_picker.FragmentScoreFilter, 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::frag_picker::FragmentScoreFilter::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::frag_picker::FragmentScoreFilter::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

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

allows printing data to a stream

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

report_sm(self: pyrosetta.rosetta.protocols.frag_picker.FragmentScoreFilter, pose: pyrosetta.rosetta.core.pose.Pose) → float

required for reporting score values

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

rescore_fragment_crmsd(self: pyrosetta.rosetta.protocols.frag_picker.FragmentScoreFilter, pose: pyrosetta.rosetta.core.pose.Pose, candidates: pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t, fc: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentCrmsd) → None

C++: protocols::frag_picker::FragmentScoreFilter::rescore_fragment_crmsd(const class std::shared_ptr<class core::pose::Pose>, class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > >, class protocols::frag_picker::scores::FragmentCrmsd *) const –> 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 class std::basic_string<char> &) –> void

setup_fragment_picker(self: pyrosetta.rosetta.protocols.frag_picker.FragmentScoreFilter, pose: pyrosetta.rosetta.core.pose.Pose, picker: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) → None

C++: protocols::frag_picker::FragmentScoreFilter::setup_fragment_picker(const class std::shared_ptr<class core::pose::Pose>, class std::shared_ptr<class protocols::frag_picker::FragmentPicker>) const –> void

class pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule

Bases: pybind11_builtins.pybind11_object

selects a given number of fragments just by selecting the best ones

assign(self: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule, : pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule) → pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule

C++: protocols::frag_picker::FragmentSelectingRule::operator=(const class protocols::frag_picker::FragmentSelectingRule &) –> class protocols::frag_picker::FragmentSelectingRule &

frags_per_pos(self: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule) → int

Says how many fragments will be selected for each position in a query sequence

C++: protocols::frag_picker::FragmentSelectingRule::frags_per_pos() –> unsigned long

select_fragments(self: pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule, : pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t, : pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t) → None

Selects desired number of fragments from a given candidates

C++: protocols::frag_picker::FragmentSelectingRule::select_fragments(const class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &, class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &) –> void

class pyrosetta.rosetta.protocols.frag_picker.GrabAllCollector

Bases: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector

Keeps all fragments candidates for the final selection

The purpose of a collector is to keep fragment candidates to the end of vall processing. This simple implementation keeps all candidates which might use huge memory

add(self: pyrosetta.rosetta.protocols.frag_picker.GrabAllCollector, new_canditate: Tuple[pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap]) → bool

Insert a fragment candidate to the container

C++: protocols::frag_picker::GrabAllCollector::add(struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >) –> bool

assign(self: pyrosetta.rosetta.protocols.frag_picker.GrabAllCollector, : pyrosetta.rosetta.protocols.frag_picker.GrabAllCollector) → pyrosetta.rosetta.protocols.frag_picker.GrabAllCollector

C++: protocols::frag_picker::GrabAllCollector::operator=(const class protocols::frag_picker::GrabAllCollector &) –> class protocols::frag_picker::GrabAllCollector &

clear(self: pyrosetta.rosetta.protocols.frag_picker.GrabAllCollector) → None

C++: protocols::frag_picker::GrabAllCollector::clear() –> void

count_candidates(*args, **kwargs)

Overloaded function.

1. count_candidates(self: pyrosetta.rosetta.protocols.frag_picker.GrabAllCollector, seq_pos: int) -> int

Check how many candidates have been already collected for a given position

C++: protocols::frag_picker::GrabAllCollector::count_candidates(unsigned long) const –> unsigned long

2. count_candidates(self: pyrosetta.rosetta.protocols.frag_picker.GrabAllCollector) -> int

Check how many candidates have been already collected for all positions

C++: protocols::frag_picker::GrabAllCollector::count_candidates() const –> unsigned long

get_candidates(self: pyrosetta.rosetta.protocols.frag_picker.GrabAllCollector, position_in_query: int) → pyrosetta.rosetta.utility.vector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_t

returns all stored fragment candidates that begins at a given position in a query

C++: protocols::frag_picker::GrabAllCollector::get_candidates(unsigned long) –> class utility::vector1<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >, class std::allocator<struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > > > &

insert(self: pyrosetta.rosetta.protocols.frag_picker.GrabAllCollector, pos: int, collector: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector) → None

Inserts candidates from another Collector for a give position in the query

C++: protocols::frag_picker::GrabAllCollector::insert(unsigned long, class std::shared_ptr<class protocols::frag_picker::CandidatesCollector>) –> void

print_report(self: pyrosetta.rosetta.protocols.frag_picker.GrabAllCollector, output: pyrosetta.rosetta.std.ostream, : pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreManager) → None

prints how many fragments have been collected for each position

C++: protocols::frag_picker::GrabAllCollector::print_report(class std::basic_ostream<char> &, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreManager>) const –> void

query_length(self: pyrosetta.rosetta.protocols.frag_picker.GrabAllCollector) → int

Check the size of query sequence that this object knows.

This is mainly to be able to check if it is the same as in the other parts of fragment picking machinery.

C++: protocols::frag_picker::GrabAllCollector::query_length() const –> unsigned long

class pyrosetta.rosetta.protocols.frag_picker.SidechainContactDistCutoff

Bases: pybind11_builtins.pybind11_object

defines sidechain contact distance cutoffs.

provides amino acid pair specific distance cutoffs.

assign(self: pyrosetta.rosetta.protocols.frag_picker.SidechainContactDistCutoff, : pyrosetta.rosetta.protocols.frag_picker.SidechainContactDistCutoff) → pyrosetta.rosetta.protocols.frag_picker.SidechainContactDistCutoff

C++: protocols::frag_picker::SidechainContactDistCutoff::operator=(const class protocols::frag_picker::SidechainContactDistCutoff &) –> class protocols::frag_picker::SidechainContactDistCutoff &

get_cutoff(self: pyrosetta.rosetta.protocols.frag_picker.SidechainContactDistCutoff, aa_i: str, aa_j: str) → float

C++: protocols::frag_picker::SidechainContactDistCutoff::get_cutoff(char, char) –> double

get_cutoff_squared(self: pyrosetta.rosetta.protocols.frag_picker.SidechainContactDistCutoff, aa_i: str, aa_j: str) → float

C++: protocols::frag_picker::SidechainContactDistCutoff::get_cutoff_squared(char, char) –> double

scale_factor(self: pyrosetta.rosetta.protocols.frag_picker.SidechainContactDistCutoff) → float

C++: protocols::frag_picker::SidechainContactDistCutoff::scale_factor() –> double

class pyrosetta.rosetta.protocols.frag_picker.VallChunk

Bases: pybind11_builtins.pybind11_object

represents a chunk of residues extracted from a vall.

VallChunk contains a vector of VallResidue objects and provides a basic ways to access them

assign(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk, : pyrosetta.rosetta.protocols.frag_picker.VallChunk) → pyrosetta.rosetta.protocols.frag_picker.VallChunk

C++: protocols::frag_picker::VallChunk::operator=(const class protocols::frag_picker::VallChunk &) –> class protocols::frag_picker::VallChunk &

at(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk, index: int) → pyrosetta.rosetta.protocols.frag_picker.VallResidue

returns i-th residue form this chunk. The first residue has index 1

C++: protocols::frag_picker::VallChunk::at(unsigned long) const –> class std::shared_ptr<class protocols::frag_picker::VallResidue>

chunk_key(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → str

returns a string that is unique for each chunk in vall

C++: protocols::frag_picker::VallChunk::chunk_key() –> std::string &

get_chain_id(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → str

returns protein chain ID

C++: protocols::frag_picker::VallChunk::get_chain_id() const –> char

get_pdb_id(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → str

returns a PDB id (a string of four letters, e.g. “4mba”)

C++: protocols::frag_picker::VallChunk::get_pdb_id() const –> std::string

get_pose(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → pyrosetta.rosetta.core.pose.Pose

returns a pose created for this chunk

the pose object is created when this function is called for the first time and then cached within a VallProvider object Every time this method is called for a new chunk, VallProvider caches new data

C++: protocols::frag_picker::VallChunk::get_pose() –> class std::shared_ptr<class core::pose::Pose>

get_profile(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → pyrosetta.rosetta.core.sequence.SequenceProfile

returns amino acid profile of this chunk

the profile object is created when this function is called for the first time and then cached within a VallProvider object. Every time this method is called for a new chunk, VallProvider caches new data

C++: protocols::frag_picker::VallChunk::get_profile() –> class std::shared_ptr<class core::sequence::SequenceProfile>

get_self_ptr(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → pyrosetta.rosetta.protocols.frag_picker.VallChunk

C++: protocols::frag_picker::VallChunk::get_self_ptr() –> class std::shared_ptr<class protocols::frag_picker::VallChunk>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → pyrosetta.rosetta.std.weak_ptr_protocols_frag_picker_VallChunk_t

C++: protocols::frag_picker::VallChunk::get_self_weak_ptr() –> class std::weak_ptr<class protocols::frag_picker::VallChunk>

get_sequence(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → str

returns amino acid sequence of this chunk

C++: protocols::frag_picker::VallChunk::get_sequence() –> std::string &

get_vall_filename(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → str

returns the Vall file used for this chunk

C++: protocols::frag_picker::VallChunk::get_vall_filename() –> std::string

get_vall_provider(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → protocols::frag_picker::VallProvider

returns the Vall Provider

C++: protocols::frag_picker::VallChunk::get_vall_provider() –> class std::shared_ptr<class protocols::frag_picker::VallProvider>

key(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → int

returns integer key of this chunk, which is the key of this chunk’s first residue

C++: protocols::frag_picker::VallChunk::key() const –> unsigned long

push_back(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk, what: pyrosetta.rosetta.protocols.frag_picker.VallResidue) → None

appends a residue to this chunk

C++: protocols::frag_picker::VallChunk::push_back(class std::shared_ptr<class protocols::frag_picker::VallResidue>) –> void

size(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → int

returns the size of this chunk i.e. the number of residues stored in there

C++: protocols::frag_picker::VallChunk::size() const –> unsigned long

vall_key(*args, **kwargs)

Overloaded function.

1. vall_key(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk) -> int

C++: protocols::frag_picker::VallChunk::vall_key() const –> unsigned long

2. vall_key(self: pyrosetta.rosetta.protocols.frag_picker.VallChunk, key: int) -> None

C++: protocols::frag_picker::VallChunk::vall_key(unsigned long) –> void

class pyrosetta.rosetta.protocols.frag_picker.VallChunkFilter

Bases: pybind11_builtins.pybind11_object

a base class for a chunk filtering mechanism

Chunk filtering is used to screen chunks before any fragment is evaluated Therefore it is the fastest way to excluded unwanted proteins

AllowPdbIdFilter and DenyPdbIdFilter for implementations

assign(self: pyrosetta.rosetta.protocols.frag_picker.VallChunkFilter, : pyrosetta.rosetta.protocols.frag_picker.VallChunkFilter) → pyrosetta.rosetta.protocols.frag_picker.VallChunkFilter

C++: protocols::frag_picker::VallChunkFilter::operator=(const class protocols::frag_picker::VallChunkFilter &) –> class protocols::frag_picker::VallChunkFilter &

test_chunk(self: pyrosetta.rosetta.protocols.frag_picker.VallChunkFilter, : pyrosetta.rosetta.protocols.frag_picker.VallChunk) → bool

if a chunk seems to be interesting, return true. Otherwise say false

C++: protocols::frag_picker::VallChunkFilter::test_chunk(class std::shared_ptr<class protocols::frag_picker::VallChunk>) –> bool

class pyrosetta.rosetta.protocols.frag_picker.VallProvider

Bases: pybind11_builtins.pybind11_object

a vector of vall chunks

assign(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, : pyrosetta.rosetta.protocols.frag_picker.VallProvider) → pyrosetta.rosetta.protocols.frag_picker.VallProvider

C++: protocols::frag_picker::VallProvider::operator=(const class protocols::frag_picker::VallProvider &) –> class protocols::frag_picker::VallProvider &

at(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, index: int) → pyrosetta.rosetta.protocols.frag_picker.VallChunk

returns a certain chunk (starts from 1)

C++: protocols::frag_picker::VallProvider::at(unsigned long) –> class std::shared_ptr<class protocols::frag_picker::VallChunk>

cache_pose(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, source_chunk: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → pyrosetta.rosetta.core.pose.Pose

cache a pose for a given chunk

C++: protocols::frag_picker::VallProvider::cache_pose(class std::shared_ptr<class protocols::frag_picker::VallChunk>) –> class std::shared_ptr<class core::pose::Pose>

cache_profile(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, source_chunk: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → pyrosetta.rosetta.core.sequence.SequenceProfile

cache a sequence profile for a given chunk

C++: protocols::frag_picker::VallProvider::cache_profile(class std::shared_ptr<class protocols::frag_picker::VallChunk>) –> class std::shared_ptr<class core::sequence::SequenceProfile>

find_chunk(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, : str, : str, : int) → pyrosetta.rosetta.protocols.frag_picker.VallChunk

tries to find a chunk defined by PDB id, chain id and a residue

sequence id

If this VallProvider does not contain a desired chunk, 0 is returned.

C++: protocols::frag_picker::VallProvider::find_chunk(class std::basic_string<char>, char, unsigned long) –> class std::shared_ptr<class protocols::frag_picker::VallChunk>

get_largest_chunk_size(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider) → int

says what is the length of the largest chunk known to this

provider

C++: protocols::frag_picker::VallProvider::get_largest_chunk_size() –> unsigned long

get_self_ptr(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider) → pyrosetta.rosetta.protocols.frag_picker.VallProvider

C++: protocols::frag_picker::VallProvider::get_self_ptr() –> class std::shared_ptr<class protocols::frag_picker::VallProvider>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider) → pyrosetta.rosetta.std.weak_ptr_protocols_frag_picker_VallProvider_t

C++: protocols::frag_picker::VallProvider::get_self_weak_ptr() –> class std::weak_ptr<class protocols::frag_picker::VallProvider>

get_vall_by_key(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, index: int) → str

C++: protocols::frag_picker::VallProvider::get_vall_by_key(unsigned long) –> std::string

get_vall_count(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider) → int

C++: protocols::frag_picker::VallProvider::get_vall_count() –> unsigned long

get_vall_end_line_by_key(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, index: int) → int

C++: protocols::frag_picker::VallProvider::get_vall_end_line_by_key(unsigned long) –> unsigned long

get_vall_last_residue_key_by_key(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, index: int) → int

C++: protocols::frag_picker::VallProvider::get_vall_last_residue_key_by_key(unsigned long) –> unsigned long

get_vall_start_line_by_key(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, index: int) → int

C++: protocols::frag_picker::VallProvider::get_vall_start_line_by_key(unsigned long) –> unsigned long

push_back(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, what: pyrosetta.rosetta.protocols.frag_picker.VallChunk) → None

adds a new chunk to this provider

C++: protocols::frag_picker::VallProvider::push_back(class std::shared_ptr<class protocols::frag_picker::VallChunk>) –> void

size(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider) → int

says how many chunks do we have

C++: protocols::frag_picker::VallProvider::size() –> unsigned long

vallChunksFromLibraries(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, fns: pyrosetta.rosetta.utility.vector1_std_string) → int

C++: protocols::frag_picker::VallProvider::vallChunksFromLibraries(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> unsigned long

vallChunksFromLibrary(*args, **kwargs)

Overloaded function.

1. vallChunksFromLibrary(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, filename: str) -> int
2. vallChunksFromLibrary(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, filename: str, startline: int) -> int
3. vallChunksFromLibrary(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, filename: str, startline: int, endline: int) -> int

Vall reader

THe defaults should ensure that the file is fully read if startline and endline ar not specified. endline = 0 means read to the end.

C++: protocols::frag_picker::VallProvider::vallChunksFromLibrary(const class std::basic_string<char> &, unsigned long, unsigned long) –> unsigned long

vallNumLines(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, filename: str) → int

Runs through the Vall and stores number of lines

C++: protocols::frag_picker::VallProvider::vallNumLines(const class std::basic_string<char> &) –> unsigned long

class pyrosetta.rosetta.protocols.frag_picker.VallResidue

Bases: pybind11_builtins.pybind11_object

class for managing a line of the Vall fragment library

aa(*args, **kwargs)

Overloaded function.

1. aa(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> str

one letter amino acid code

C++: protocols::frag_picker::VallResidue::aa() const –> char

2. aa(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, c: str) -> None

one letter amino acid code

C++: protocols::frag_picker::VallResidue::aa(const char) –> void

assign(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, rval: pyrosetta.rosetta.protocols.frag_picker.VallResidue) → pyrosetta.rosetta.protocols.frag_picker.VallResidue

copy assignment

C++: protocols::frag_picker::VallResidue::operator=(const class protocols::frag_picker::VallResidue &) –> class protocols::frag_picker::VallResidue &

bF(*args, **kwargs)

Overloaded function.

1. bF(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

b factor average for backbone

C++: protocols::frag_picker::VallResidue::bF() const –> double

2. bF(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: float) -> None

b factor average for backbone

C++: protocols::frag_picker::VallResidue::bF(const double) –> void

bbtorsion_srfd(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) → pyrosetta.rosetta.core.fragment.BBTorsionSRFD

build a BBTorsionSRFD from this page

C++: protocols::frag_picker::VallResidue::bbtorsion_srfd() const –> class std::shared_ptr<class core::fragment::BBTorsionSRFD>

cbx(*args, **kwargs)

Overloaded function.

1. cbx(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

x-coordinate of C-beta

C++: protocols::frag_picker::VallResidue::cbx() const –> double

2. cbx(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: float) -> None

x-coordinate of C-beta

C++: protocols::frag_picker::VallResidue::cbx(const double) –> void

cby(*args, **kwargs)

Overloaded function.

1. cby(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

y-coordinate of C-beta

C++: protocols::frag_picker::VallResidue::cby() const –> double

2. cby(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: float) -> None

y-coordinate of C-beta

C++: protocols::frag_picker::VallResidue::cby(const double) –> void

cbz(*args, **kwargs)

Overloaded function.

1. cbz(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

z-coordinate of C-beta

C++: protocols::frag_picker::VallResidue::cbz() const –> double

2. cbz(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: float) -> None

z-coordinate of C-beta

C++: protocols::frag_picker::VallResidue::cbz(const double) –> void

cenx(*args, **kwargs)

Overloaded function.

1. cenx(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

x-coordinate of centroid

C++: protocols::frag_picker::VallResidue::cenx() const –> double

2. cenx(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: float) -> None

x-coordinate of centroid

C++: protocols::frag_picker::VallResidue::cenx(const double) –> void

ceny(*args, **kwargs)

Overloaded function.

1. ceny(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

y-coordinate of centroid

C++: protocols::frag_picker::VallResidue::ceny() const –> double

2. ceny(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: float) -> None

y-coordinate of centroid

C++: protocols::frag_picker::VallResidue::ceny(const double) –> void

cenz(*args, **kwargs)

Overloaded function.

1. cenz(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

z-coordinate of centroid

C++: protocols::frag_picker::VallResidue::cenz() const –> double

2. cenz(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: float) -> None

z-coordinate of centroid

C++: protocols::frag_picker::VallResidue::cenz(const double) –> void

depth(*args, **kwargs)

Overloaded function.

1. depth(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

all-atom residue depth

C++: protocols::frag_picker::VallResidue::depth() const –> double

2. depth(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, depth: float) -> None

all-atom residue depth

C++: protocols::frag_picker::VallResidue::depth(const double) –> void

distance_squared(*args, **kwargs)

Overloaded function.

1. distance_squared(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, r: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

C++: protocols::frag_picker::VallResidue::distance_squared(class std::shared_ptr<const class protocols::frag_picker::VallResidue>) –> double

2. distance_squared(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, r: pyrosetta.rosetta.protocols.frag_picker.VallResidue, type: pyrosetta.rosetta.protocols.frag_picker.ContactType) -> float

C++: protocols::frag_picker::VallResidue::distance_squared(class std::shared_ptr<const class protocols::frag_picker::VallResidue>, const enum protocols::frag_picker::ContactType &) –> double

distance_squared_cb(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, r: pyrosetta.rosetta.protocols.frag_picker.VallResidue) → float

C++: protocols::frag_picker::VallResidue::distance_squared_cb(class std::shared_ptr<const class protocols::frag_picker::VallResidue>) –> double

distance_squared_cen(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, r: pyrosetta.rosetta.protocols.frag_picker.VallResidue) → float

C++: protocols::frag_picker::VallResidue::distance_squared_cen(class std::shared_ptr<const class protocols::frag_picker::VallResidue>) –> double

dssp_phi(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) → float

phi backbone torsion in degrees from DSSP

C++: protocols::frag_picker::VallResidue::dssp_phi() const –> double

dssp_psi(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) → float

psi backbone torsion in degrees from DSSP

C++: protocols::frag_picker::VallResidue::dssp_psi() const –> double

fill_from_string(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, line: str) → None

fill internal data from string

C++: protocols::frag_picker::VallResidue::fill_from_string(const class std::basic_string<char> &) –> void

fill_from_string_cs(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, line: str) → None

fill internal data from string

C++: protocols::frag_picker::VallResidue::fill_from_string_cs(const class std::basic_string<char> &) –> void

fill_from_string_residue_depth_version1(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, line: str) → None

C++: protocols::frag_picker::VallResidue::fill_from_string_residue_depth_version1(const class std::basic_string<char> &) –> void

fill_from_string_version1(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, line: str) → None

fill internal data from string

C++: protocols::frag_picker::VallResidue::fill_from_string_version1(const class std::basic_string<char> &) –> void

has_chemical_shifts(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) → bool

C++: protocols::frag_picker::VallResidue::has_chemical_shifts() const –> bool

has_profile(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) → bool

has profile info?

C++: protocols::frag_picker::VallResidue::has_profile() const –> bool

has_profile_struct(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) → bool

has structure profile info?

C++: protocols::frag_picker::VallResidue::has_profile_struct() const –> bool

id(*args, **kwargs)

Overloaded function.

1. id(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> str

id of fragment source (e.g. pdb name)

C++: protocols::frag_picker::VallResidue::id() const –> const std::string &

2. id(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, s: str) -> None

id of fragment source (e.g. pdb name)

C++: protocols::frag_picker::VallResidue::id(const class std::basic_string<char> &) –> void

key(*args, **kwargs)

Overloaded function.

1. key(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, key: int) -> None

sets the key id

C++: protocols::frag_picker::VallResidue::key(unsigned long) –> void

2. key(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> int

sets the key id

C++: protocols::frag_picker::VallResidue::key() –> unsigned long

nali(*args, **kwargs)

Overloaded function.

1. nali(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> int

number of alignments

C++: protocols::frag_picker::VallResidue::nali() const –> unsigned long

2. nali(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: int) -> None

number of alignments

C++: protocols::frag_picker::VallResidue::nali(const unsigned long) –> void

omega(*args, **kwargs)

Overloaded function.

1. omega(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

omega backbone torsion in degrees

C++: protocols::frag_picker::VallResidue::omega() const –> double

2. omega(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: float) -> None

omega backbone torsion in degrees

C++: protocols::frag_picker::VallResidue::omega(const double) –> void

phi(*args, **kwargs)

Overloaded function.

1. phi(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

phi backbone torsion in degrees

C++: protocols::frag_picker::VallResidue::phi() const –> double

2. phi(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: float) -> None

phi backbone torsion in degrees

C++: protocols::frag_picker::VallResidue::phi(const double) –> void

profile(*args, **kwargs)

Overloaded function.

1. profile(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> pyrosetta.rosetta.utility.vector1_double

per amino acid profile data

C++: protocols::frag_picker::VallResidue::profile() const –> const class utility::vector1<double, class std::allocator<double> > &

2. profile(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, v: pyrosetta.rosetta.utility.vector1_double) -> None

per amino acid profile data

C++: protocols::frag_picker::VallResidue::profile(const class utility::vector1<double, class std::allocator<double> > &) –> void

profile_struct(*args, **kwargs)

Overloaded function.

1. profile_struct(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> pyrosetta.rosetta.utility.vector1_double

per amino acid structure profile data

C++: protocols::frag_picker::VallResidue::profile_struct() const –> const class utility::vector1<double, class std::allocator<double> > &

2. profile_struct(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, v: pyrosetta.rosetta.utility.vector1_double) -> None

per amino acid structure profile data

C++: protocols::frag_picker::VallResidue::profile_struct(const class utility::vector1<double, class std::allocator<double> > &) –> void

psi(*args, **kwargs)

Overloaded function.

1. psi(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

psi backbone torsion in degrees

C++: protocols::frag_picker::VallResidue::psi() const –> double

2. psi(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: float) -> None

psi backbone torsion in degrees

C++: protocols::frag_picker::VallResidue::psi(const double) –> void

resi(*args, **kwargs)

Overloaded function.

1. resi(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> int

residue sequence number in source

C++: protocols::frag_picker::VallResidue::resi() const –> unsigned long

2. resi(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, i: int) -> None

residue sequence number in source

C++: protocols::frag_picker::VallResidue::resi(const unsigned long) –> void

sa(*args, **kwargs)

Overloaded function.

1. sa(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

solvent accessible area

C++: protocols::frag_picker::VallResidue::sa() const –> double

2. sa(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: float) -> None

solvent accessible area

C++: protocols::frag_picker::VallResidue::sa(const double) –> void

sa_norm(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) → float

solvent accessible area normalized

C++: protocols::frag_picker::VallResidue::sa_norm() const –> double

secondary_shifts(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) → pyrosetta.rosetta.utility.vector1_double

secondary chemical shifts

C++: protocols::frag_picker::VallResidue::secondary_shifts() –> const class utility::vector1<double, class std::allocator<double> > &

set_ss_from_str(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) → None

C++: protocols::frag_picker::VallResidue::set_ss_from_str() –> void

ss(*args, **kwargs)

Overloaded function.

1. ss(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> str

one letter secondary structure code

C++: protocols::frag_picker::VallResidue::ss() const –> char

2. ss(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, c: str) -> None

one letter secondary structure code

C++: protocols::frag_picker::VallResidue::ss(const char) –> void

ss_str(*args, **kwargs)

Overloaded function.

1. ss_str(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> str

one letter secondary structure STR code

C++: protocols::frag_picker::VallResidue::ss_str() const –> char

2. ss_str(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, c: str) -> None

one letter secondary structure STR code

C++: protocols::frag_picker::VallResidue::ss_str(const char) –> void

x(*args, **kwargs)

Overloaded function.

1. x(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

x-coordinate of C-alpha

C++: protocols::frag_picker::VallResidue::x() const –> double

2. x(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: float) -> None

x-coordinate of C-alpha

C++: protocols::frag_picker::VallResidue::x(const double) –> void

y(*args, **kwargs)

Overloaded function.

1. y(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

y-coordinate of C-alpha

C++: protocols::frag_picker::VallResidue::y() const –> double

2. y(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: float) -> None

y-coordinate of C-alpha

C++: protocols::frag_picker::VallResidue::y(const double) –> void

z(*args, **kwargs)

Overloaded function.

1. z(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue) -> float

z-coordinate of C-alpha

C++: protocols::frag_picker::VallResidue::z() const –> double

2. z(self: pyrosetta.rosetta.protocols.frag_picker.VallResidue, val: float) -> None

z-coordinate of C-alpha

C++: protocols::frag_picker::VallResidue::z(const double) –> void

pyrosetta.rosetta.protocols.frag_picker.contact_name(type: pyrosetta.rosetta.protocols.frag_picker.ContactType) → str

give an enum type and return the string name

C++: protocols::frag_picker::contact_name(enum protocols::frag_picker::ContactType) –> std::string

pyrosetta.rosetta.protocols.frag_picker.contact_type(name: str) → pyrosetta.rosetta.protocols.frag_picker.ContactType

give a string name and return its enum type

C++: protocols::frag_picker::contact_type(const class std::basic_string<char> &) –> enum protocols::frag_picker::ContactType

pyrosetta.rosetta.protocols.frag_picker.convert_binary_checkpoint(check_filename: str) → None

C++: protocols::frag_picker::convert_binary_checkpoint(const class std::basic_string<char> &) –> void

pyrosetta.rosetta.protocols.frag_picker.run_command(command: str) → None

C++: protocols::frag_picker::run_command(const class std::basic_string<char> &) –> void

pyrosetta.rosetta.protocols.frag_picker.sa_faraggi_max(aa: str) → float

C++: protocols::frag_picker::sa_faraggi_max(char) –> double