frag_picker¶

Bindings for protocols::frag_picker namespace

class pyrosetta.rosetta.protocols.frag_picker.AllowPdbIdFilter¶

Bases: 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(std::string) –> 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<std::string, class std::allocator<std::string > >) –> 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(std::string) –> 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(std::ostream &) –> 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: 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.BoundedCollector_CompareTotalScore¶

Bases: BoundedCollector_protocols_frag_picker_CompareTotalScore_t

add(*args, **kwargs)¶

Overloaded function.

add(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, new_canditate: Tuple[pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap]) -> bool

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

add(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, : 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.BoundedCollector_CompareTotalScore, : pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_CompareTotalScore) → pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_CompareTotalScore¶: C++: protocols::frag_picker::BoundedCollector_CompareTotalScore::operator=(const class protocols::frag_picker::BoundedCollector_CompareTotalScore &) –> class protocols::frag_picker::BoundedCollector_CompareTotalScore &

clear(*args, **kwargs)¶

Overloaded function.

clear(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t) -> None

C++: protocols::frag_picker::BoundedCollector<protocols::frag_picker::CompareTotalScore>::clear() –> void

clear(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t) -> None

removes all candidates from the container

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

count_candidates(*args, **kwargs)¶

Overloaded function.

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

C++: protocols::frag_picker::BoundedCollector<protocols::frag_picker::CompareTotalScore>::count_candidates(unsigned long) const –> unsigned long

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

C++: protocols::frag_picker::BoundedCollector<protocols::frag_picker::CompareTotalScore>::count_candidates() const –> unsigned long

count_candidates(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, : 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

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

Check how many candidates have been already collected for all positions

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

get_candidates(*args, **kwargs)¶

Overloaded function.

get_candidates(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, 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::BoundedCollector<protocols::frag_picker::CompareTotalScore>::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> > > > &

get_candidates(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, 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(*args, **kwargs)¶

Overloaded function.

insert(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, pos: int, collector: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector) -> None

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

insert(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, : 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(*args, **kwargs)¶

Overloaded function.

print_report(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, out: pyrosetta.rosetta.std.ostream, scoring: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreManager) -> None

C++: protocols::frag_picker::BoundedCollector<protocols::frag_picker::CompareTotalScore>::print_report(std::ostream &, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreManager>) const –> void

print_report(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, 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(std::ostream &, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreManager>) const –> void

query_length(*args, **kwargs)¶

Overloaded function.

query_length(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t) -> int

C++: protocols::frag_picker::BoundedCollector<protocols::frag_picker::CompareTotalScore>::query_length() const –> unsigned long

query_length(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t) -> 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.BoundedCollector_protocols_frag_picker_CompareTotalScore_t¶

Bases: CandidatesCollector

add(*args, **kwargs)¶

Overloaded function.

add(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, new_canditate: Tuple[pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap]) -> bool

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

add(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, : 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(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, : pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t) -> pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t

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

assign(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, : 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(*args, **kwargs)¶

Overloaded function.

clear(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t) -> None

C++: protocols::frag_picker::BoundedCollector<protocols::frag_picker::CompareTotalScore>::clear() –> void

clear(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t) -> None

removes all candidates from the container

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

count_candidates(*args, **kwargs)¶

Overloaded function.

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

C++: protocols::frag_picker::BoundedCollector<protocols::frag_picker::CompareTotalScore>::count_candidates(unsigned long) const –> unsigned long

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

C++: protocols::frag_picker::BoundedCollector<protocols::frag_picker::CompareTotalScore>::count_candidates() const –> unsigned long

count_candidates(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, : 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

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

Check how many candidates have been already collected for all positions

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

get_candidates(*args, **kwargs)¶

Overloaded function.

get_candidates(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, 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::BoundedCollector<protocols::frag_picker::CompareTotalScore>::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> > > > &

get_candidates(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, 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(*args, **kwargs)¶

Overloaded function.

insert(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, pos: int, collector: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector) -> None

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

insert(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, : 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(*args, **kwargs)¶

Overloaded function.

print_report(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, out: pyrosetta.rosetta.std.ostream, scoring: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreManager) -> None

C++: protocols::frag_picker::BoundedCollector<protocols::frag_picker::CompareTotalScore>::print_report(std::ostream &, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreManager>) const –> void

print_report(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t, 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(std::ostream &, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreManager>) const –> void

query_length(*args, **kwargs)¶

Overloaded function.

query_length(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t) -> int

C++: protocols::frag_picker::BoundedCollector<protocols::frag_picker::CompareTotalScore>::query_length() const –> unsigned long

query_length(self: pyrosetta.rosetta.protocols.frag_picker.BoundedCollector_protocols_frag_picker_CompareTotalScore_t) -> 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.CS2ndShift¶

Bases: pybind11_object

shifts(self: pyrosetta.rosetta.protocols.frag_picker.CS2ndShift) → pyrosetta.rosetta.utility.vector1_utility_vector1_std_pair_unsigned_long_double_std_allocator_std_pair_unsigned_long_double_t¶: C++: protocols::frag_picker::CS2ndShift::shifts() –> class utility::vector1<class utility::vector1<struct std::pair<unsigned long, double>, class std::allocator<struct std::pair<unsigned long, double> > >, class std::allocator<class utility::vector1<struct std::pair<unsigned long, double>, class std::allocator<struct std::pair<unsigned long, double> > > > >

class pyrosetta.rosetta.protocols.frag_picker.CSTalosIO¶

Bases: pybind11_object

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

get_first_residue_id(self: pyrosetta.rosetta.protocols.frag_picker.CSTalosIO) → int¶: C++: protocols::frag_picker::CSTalosIO::get_first_residue_id() const –> unsigned long

get_last_residue_id(self: pyrosetta.rosetta.protocols.frag_picker.CSTalosIO) → int¶: C++: protocols::frag_picker::CSTalosIO::get_last_residue_id() const –> unsigned long

get_sequence(self: pyrosetta.rosetta.protocols.frag_picker.CSTalosIO) → str¶: C++: protocols::frag_picker::CSTalosIO::get_sequence() const –> std::string

get_shift(self: pyrosetta.rosetta.protocols.frag_picker.CSTalosIO, : int, : str) → float¶: C++: protocols::frag_picker::CSTalosIO::get_shift(unsigned long, const std::string &) const –> double

has_atom(self: pyrosetta.rosetta.protocols.frag_picker.CSTalosIO, : int, : str) → bool¶: C++: protocols::frag_picker::CSTalosIO::has_atom(unsigned long, const std::string &) const –> bool

has_entry(self: pyrosetta.rosetta.protocols.frag_picker.CSTalosIO, residue_id: int) → bool¶: C++: protocols::frag_picker::CSTalosIO::has_entry(unsigned long) –> bool

read(self: pyrosetta.rosetta.protocols.frag_picker.CSTalosIO, : str) → None¶: C++: protocols::frag_picker::CSTalosIO::read(const std::string &) –> void

repack_to_matrix(self: pyrosetta.rosetta.protocols.frag_picker.CSTalosIO) → pyrosetta.rosetta.utility.vector1_utility_vector1_std_pair_unsigned_long_double_std_allocator_std_pair_unsigned_long_double_t¶: C++: protocols::frag_picker::CSTalosIO::repack_to_matrix() –> class utility::vector1<class utility::vector1<struct std::pair<unsigned long, double>, class std::allocator<struct std::pair<unsigned long, double> > >, class std::allocator<class utility::vector1<struct std::pair<unsigned long, double>, class std::allocator<struct std::pair<unsigned long, double> > > > >

write(self: pyrosetta.rosetta.protocols.frag_picker.CSTalosIO, : pyrosetta.rosetta.std.ostream) → None¶: C++: protocols::frag_picker::CSTalosIO::write(std::ostream &) –> void

class pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector¶

Bases: 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.

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

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(std::ostream &, 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: 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: 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: 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: 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: 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.Contact¶

Bases: pybind11_object

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

dist(self: pyrosetta.rosetta.protocols.frag_picker.Contact) → float¶: C++: protocols::frag_picker::Contact::dist() –> double

dist_squared(self: pyrosetta.rosetta.protocols.frag_picker.Contact) → float¶: C++: protocols::frag_picker::Contact::dist_squared() –> double &

i(self: pyrosetta.rosetta.protocols.frag_picker.Contact) → int¶: C++: protocols::frag_picker::Contact::i() –> unsigned long &

j(self: pyrosetta.rosetta.protocols.frag_picker.Contact) → int¶: C++: protocols::frag_picker::Contact::j() –> unsigned long &

type(self: pyrosetta.rosetta.protocols.frag_picker.Contact) → pyrosetta.rosetta.protocols.frag_picker.ContactType¶: C++: protocols::frag_picker::Contact::type() –> enum protocols::frag_picker::ContactType &

type_name(self: pyrosetta.rosetta.protocols.frag_picker.Contact) → str¶: C++: protocols::frag_picker::Contact::type_name() –> std::string

class pyrosetta.rosetta.protocols.frag_picker.ContactCounts¶

Bases: pybind11_object

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

counts(self: pyrosetta.rosetta.protocols.frag_picker.ContactCounts) → pyrosetta.rosetta.std.map_std_pair_unsigned_long_unsigned_long_t_unsigned_long_std_less_std_pair_unsigned_long_unsigned_long_t_std_allocator_std_pair_const_std_pair_unsigned_long_unsigned_long_unsigned_long_t¶: C++: protocols::frag_picker::ContactCounts::counts() –> class std::map<struct std::pair<unsigned long, unsigned long>, unsigned long, struct std::less<struct std::pair<unsigned long, unsigned long> >, class std::allocator<struct std::pair<const struct std::pair<unsigned long, unsigned long>, unsigned long> > > &

class pyrosetta.rosetta.protocols.frag_picker.ContactType¶

Bases: pybind11_object

Members:

CA

CB

CEN

UNK

num_contact_types

CA = <ContactType.CA: 1>¶

CB = <ContactType.CB: 2>¶

CEN = <ContactType.CEN: 3>¶

UNK = <ContactType.UNK: 4>¶

property name¶

num_contact_types = <ContactType.UNK: 4>¶

property value¶

class pyrosetta.rosetta.protocols.frag_picker.CustomScoreSelector¶

Bases: 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: 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(std::string) –> 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<std::string, class std::allocator<std::string > >) –> 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(std::string) –> 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(std::ostream &) –> 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: 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: 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: 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_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: protocols::frag_picker::scores::FragmentScoreManager) → None¶

Prints fragment to silent struct

C++: protocols::frag_picker::FragmentCandidate::output_silent(class core::io::silent::SilentFileData &, const std::string &, const std::string &, const std::string &, 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.

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

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

C++: protocols::frag_picker::FragmentCandidate::print_fragment(std::ostream &, 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(std::ostream &, 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(std::ostream &) –> 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 std::string &) –> void

class pyrosetta.rosetta.protocols.frag_picker.FragmentComparatorBase¶

Bases: pybind11_object

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

class pyrosetta.rosetta.protocols.frag_picker.FragmentPicker¶

Bases: 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: 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(std::string, std::string) –> void

add_scoring_method(*args, **kwargs)¶

Overloaded function.

add_scoring_method(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, scoring_term: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoringMethod, weight: float) -> None
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(std::string) –> void

property frag_sizes_¶

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.

get_candidates_collector(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, frag_size: int) -> pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector
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.

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

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

get_score_manager(*args, **kwargs)¶

Overloaded function.

get_score_manager(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker) -> pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreManager
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) → 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.

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

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

property n_candidates_¶

property n_frags_¶

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.

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

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

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, chunk: pyrosetta.rosetta.protocols.frag_picker.VallChunk, assignments: pyrosetta.rosetta.basic.thread_manager.RosettaThreadAssignmentInfo) → None¶

multi-threaded task

C++: protocols::frag_picker::FragmentPicker::pick_chunk_candidates(class std::shared_ptr<class protocols::frag_picker::VallChunk>, const class basic::thread_manager::RosettaThreadAssignmentInfo &) –> void

property prefix_¶

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 std::string &) –> 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 std::string &, std::string) –> 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 std::string &) –> 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 std::string &, const std::string &) –> 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(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> 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 std::string &, std::string) –> void

read_vall(*args, **kwargs)¶

Overloaded function.

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

reads a vall file

C++: protocols::frag_picker::FragmentPicker::read_vall(const std::string &) –> void

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<std::string, class std::allocator<std::string > > &) –> 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

property selector_¶

set_candidates_collector(*args, **kwargs)¶

Overloaded function.

set_candidates_collector(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, frag_size: int, sink: pyrosetta.rosetta.protocols.frag_picker.CandidatesCollector) -> None
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_max_threads(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, setting: int) → None¶

Set the number of threads to use.

A value of zero means use all available threads.

Vikram K. Mulligan (vmulligan.org)

C++: protocols::frag_picker::FragmentPicker::set_max_threads(const unsigned long) –> 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.

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

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.

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

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

show_scoring_methods(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, out: pyrosetta.rosetta.std.ostream) -> None
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(std::ostream &, 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.

total_score(self: pyrosetta.rosetta.protocols.frag_picker.FragmentPicker, f: pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap) -> float
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: 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

static 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) → 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 &) –> void

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

Provide citations to the passed CitationCollectionList

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

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

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

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::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(std::ostream &, 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: 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 std::string &) –> 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.FragmentScoreFilterCreator¶

Bases: FilterCreator

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

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

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

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

class pyrosetta.rosetta.protocols.frag_picker.FragmentSelectingRule¶

Bases: 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: 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.

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

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(std::ostream &, 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.JCouplingIO¶

Bases: pybind11_object

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

get_data(self: pyrosetta.rosetta.protocols.frag_picker.JCouplingIO, res_num: int, has_data: bool) → Tuple[float, float]¶: C++: protocols::frag_picker::JCouplingIO::get_data(const unsigned long, bool &) –> struct std::pair<double, double>

get_length(self: pyrosetta.rosetta.protocols.frag_picker.JCouplingIO) → int¶: C++: protocols::frag_picker::JCouplingIO::get_length() –> unsigned long

get_parameters(self: pyrosetta.rosetta.protocols.frag_picker.JCouplingIO) → pyrosetta.rosetta.utility.vector1_double¶: C++: protocols::frag_picker::JCouplingIO::get_parameters() –> class utility::vector1<double, class std::allocator<double> >

read(self: pyrosetta.rosetta.protocols.frag_picker.JCouplingIO, : str) → None¶: C++: protocols::frag_picker::JCouplingIO::read(const std::string &) –> void

class pyrosetta.rosetta.protocols.frag_picker.LAMBEGO_IO¶

Bases: pybind11_object

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

matrix(self: pyrosetta.rosetta.protocols.frag_picker.LAMBEGO_IO) → pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t¶: C++: protocols::frag_picker::LAMBEGO_IO::matrix() const –> const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &

nrows(self: pyrosetta.rosetta.protocols.frag_picker.LAMBEGO_IO) → int¶: C++: protocols::frag_picker::LAMBEGO_IO::nrows() const –> unsigned long

prof_row(self: pyrosetta.rosetta.protocols.frag_picker.LAMBEGO_IO, idx: int) → pyrosetta.rosetta.utility.vector1_double¶: C++: protocols::frag_picker::LAMBEGO_IO::prof_row(const unsigned long) const –> const class utility::vector1<double, class std::allocator<double> > &

read(self: pyrosetta.rosetta.protocols.frag_picker.LAMBEGO_IO, input: pyrosetta.rosetta.std.istream) → None¶: C++: protocols::frag_picker::LAMBEGO_IO::read(std::istream &) –> void

write(self: pyrosetta.rosetta.protocols.frag_picker.LAMBEGO_IO, output: pyrosetta.rosetta.std.ostream) → None¶: C++: protocols::frag_picker::LAMBEGO_IO::write(std::ostream &) –> void

class pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t, : pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t) → pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareByScoreCombination>::operator=(const class protocols::frag_picker::LazySortedVector1<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::CompareByScoreCombination> &) –> class protocols::frag_picker::LazySortedVector1<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::CompareByScoreCombination> &

clear(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t) → None¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareByScoreCombination>::clear() –> void

count_inserted(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t) → int¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareByScoreCombination>::count_inserted() const –> unsigned long

expose_data(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t) → 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::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareByScoreCombination>::expose_data() –> 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> > > > &

peek_back(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t) → Tuple[pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap]¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareByScoreCombination>::peek_back() const –> struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >

peek_front(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t) → Tuple[pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap]¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareByScoreCombination>::peek_front() const –> struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >

push(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t, x: Tuple[pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap]) → bool¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareByScoreCombination>::push(const struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > &) –> bool

resize(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t, sorted_capacity: int, max_capacity: int) → None¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareByScoreCombination>::resize(unsigned long, unsigned long) –> void

set_boundary(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t, sorted_capacity: int) → None¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareByScoreCombination>::set_boundary(unsigned long) –> void

set_worst(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t, new_worst: Tuple[pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap]) → None¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareByScoreCombination>::set_worst(struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >) –> void

size(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t) → int¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareByScoreCombination>::size() const –> unsigned long

top(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareByScoreCombination_t) → Tuple[pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap]¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareByScoreCombination>::top() –> const struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > &

class pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t, : pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t) → pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareTotalScore>::operator=(const class protocols::frag_picker::LazySortedVector1<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::CompareTotalScore> &) –> class protocols::frag_picker::LazySortedVector1<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::CompareTotalScore> &

clear(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t) → None¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareTotalScore>::clear() –> void

count_inserted(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t) → int¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareTotalScore>::count_inserted() const –> unsigned long

expose_data(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t) → 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::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareTotalScore>::expose_data() –> 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> > > > &

peek_back(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t) → Tuple[pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap]¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareTotalScore>::peek_back() const –> struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >

peek_front(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t) → Tuple[pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap]¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareTotalScore>::peek_front() const –> struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >

push(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t, x: Tuple[pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap]) → bool¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareTotalScore>::push(const struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > &) –> bool

resize(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t, sorted_capacity: int, max_capacity: int) → None¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareTotalScore>::resize(unsigned long, unsigned long) –> void

set_boundary(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t, sorted_capacity: int) → None¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareTotalScore>::set_boundary(unsigned long) –> void

set_worst(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t, new_worst: Tuple[pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap]) → None¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareTotalScore>::set_worst(struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> >) –> void

size(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t) → int¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareTotalScore>::size() const –> unsigned long

top(self: pyrosetta.rosetta.protocols.frag_picker.LazySortedVector1_std_pair_std_shared_ptr_protocols_frag_picker_FragmentCandidate_std_shared_ptr_protocols_frag_picker_scores_FragmentScoreMap_protocols_frag_picker_CompareTotalScore_t) → Tuple[pyrosetta.rosetta.protocols.frag_picker.FragmentCandidate, pyrosetta.rosetta.protocols.frag_picker.scores.FragmentScoreMap]¶: C++: protocols::frag_picker::LazySortedVector1<std::pair<std::shared_ptr<protocols::frag_picker::FragmentCandidate>, std::shared_ptr<protocols::frag_picker::scores::FragmentScoreMap> >, protocols::frag_picker::CompareTotalScore>::top() –> const struct std::pair<class std::shared_ptr<class protocols::frag_picker::FragmentCandidate>, class std::shared_ptr<class protocols::frag_picker::scores::FragmentScoreMap> > &

class pyrosetta.rosetta.protocols.frag_picker.PdbIdChunkFilter¶

Bases: VallChunkFilter

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(std::string) –> 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<std::string, class std::allocator<std::string > >) –> void

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

load_pdb_id_from_file(self: pyrosetta.rosetta.protocols.frag_picker.PdbIdChunkFilter, : str) → None¶: C++: protocols::frag_picker::PdbIdChunkFilter::load_pdb_id_from_file(std::string) –> 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(std::ostream &) –> void

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.PhiPsiTalosIO¶

Bases: pybind11_object

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

d_phi(self: pyrosetta.rosetta.protocols.frag_picker.PhiPsiTalosIO, res_id: int) → float¶: C++: protocols::frag_picker::PhiPsiTalosIO::d_phi(unsigned long) –> double

d_psi(self: pyrosetta.rosetta.protocols.frag_picker.PhiPsiTalosIO, res_id: int) → float¶: C++: protocols::frag_picker::PhiPsiTalosIO::d_psi(unsigned long) –> double

dist(self: pyrosetta.rosetta.protocols.frag_picker.PhiPsiTalosIO, res_id: int) → float¶: C++: protocols::frag_picker::PhiPsiTalosIO::dist(unsigned long) –> double

get_first_residue_id(self: pyrosetta.rosetta.protocols.frag_picker.PhiPsiTalosIO) → int¶: C++: protocols::frag_picker::PhiPsiTalosIO::get_first_residue_id() const –> unsigned long

get_last_residue_id(self: pyrosetta.rosetta.protocols.frag_picker.PhiPsiTalosIO) → int¶: C++: protocols::frag_picker::PhiPsiTalosIO::get_last_residue_id() const –> unsigned long

get_sequence(self: pyrosetta.rosetta.protocols.frag_picker.PhiPsiTalosIO) → str¶: C++: protocols::frag_picker::PhiPsiTalosIO::get_sequence() const –> const std::string &

has_entry(self: pyrosetta.rosetta.protocols.frag_picker.PhiPsiTalosIO, residue_id: int) → bool¶: C++: protocols::frag_picker::PhiPsiTalosIO::has_entry(unsigned long) const –> bool

phi(self: pyrosetta.rosetta.protocols.frag_picker.PhiPsiTalosIO, res_id: int) → float¶: C++: protocols::frag_picker::PhiPsiTalosIO::phi(unsigned long) –> double

psi(self: pyrosetta.rosetta.protocols.frag_picker.PhiPsiTalosIO, res_id: int) → float¶: C++: protocols::frag_picker::PhiPsiTalosIO::psi(unsigned long) –> double

quality(self: pyrosetta.rosetta.protocols.frag_picker.PhiPsiTalosIO, res_id: int) → str¶: C++: protocols::frag_picker::PhiPsiTalosIO::quality(unsigned long) –> std::string

read(self: pyrosetta.rosetta.protocols.frag_picker.PhiPsiTalosIO, : str) → None¶: C++: protocols::frag_picker::PhiPsiTalosIO::read(const std::string &) –> void

s2(self: pyrosetta.rosetta.protocols.frag_picker.PhiPsiTalosIO, res_id: int) → float¶: C++: protocols::frag_picker::PhiPsiTalosIO::s2(unsigned long) –> double

write(self: pyrosetta.rosetta.protocols.frag_picker.PhiPsiTalosIO, : pyrosetta.rosetta.std.ostream) → None¶: C++: protocols::frag_picker::PhiPsiTalosIO::write(std::ostream &) –> void

class pyrosetta.rosetta.protocols.frag_picker.QuotaDebug¶

Bases: ostringstream

_M_write(self: pyrosetta.rosetta.std.ostringstream, __s: str, __n: int) → None¶: C++: std::basic_ostream<char, std::char_traits<char> >::_M_write(const char *, long) –> void

bytes(self: pyrosetta.rosetta.std.ostringstream) → bytes¶

flush(self: pyrosetta.rosetta.std.ostringstream) → pyrosetta.rosetta.std.ostream¶: C++: std::basic_ostream<char, std::char_traits<char> >::flush() –> std::ostream &

log(self: pyrosetta.rosetta.protocols.frag_picker.QuotaDebug, : int, : int, : pyrosetta.rosetta.utility.vector1_double) → None¶: C++: protocols::frag_picker::QuotaDebug::log(unsigned long, unsigned long, class utility::vector1<double, class std::allocator<double> >) –> void

max_pools(self: pyrosetta.rosetta.protocols.frag_picker.QuotaDebug) → int¶: C++: protocols::frag_picker::QuotaDebug::max_pools() –> unsigned long

property nFrags_¶

put(self: pyrosetta.rosetta.std.ostringstream, __c: str) → pyrosetta.rosetta.std.ostream¶: C++: std::basic_ostream<char, std::char_traits<char> >::put(char) –> std::ostream &

rdbuf(self: pyrosetta.rosetta.std.ostringstream) → pyrosetta.rosetta.std.stringbuf¶: C++: std::basic_ostringstream<char, std::char_traits<char>, std::allocator<char> >::rdbuf() const –> class std::basic_stringbuf<char> *

seekp(*args, **kwargs)¶

Overloaded function.

seekp(self: pyrosetta.rosetta.std.ostringstream, : pyrosetta.rosetta.std.fpos___mbstate_t_t) -> pyrosetta.rosetta.std.ostream

C++: std::basic_ostream<char, std::char_traits<char> >::seekp(class std::fpos<__mbstate_t>) –> std::ostream &

seekp(self: pyrosetta.rosetta.std.ostringstream, : int, : std::_Ios_Seekdir) -> pyrosetta.rosetta.std.ostream

C++: std::basic_ostream<char, std::char_traits<char> >::seekp(long, enum std::_Ios_Seekdir) –> std::ostream &

class sentry¶: Bases: pybind11_object

setup_summary(self: pyrosetta.rosetta.protocols.frag_picker.QuotaDebug, collector_: protocols::frag_picker::quota::QuotaCollector) → None¶: C++: protocols::frag_picker::QuotaDebug::setup_summary(const class protocols::frag_picker::quota::QuotaCollector &) –> void

str(*args, **kwargs)¶

Overloaded function.

str(self: pyrosetta.rosetta.std.ostringstream) -> str

C++: std::basic_ostringstream<char, std::char_traits<char>, std::allocator<char> >::str() const –> std::string

str(self: pyrosetta.rosetta.std.ostringstream, __s: str) -> None

C++: std::basic_ostringstream<char, std::char_traits<char>, std::allocator<char> >::str(const std::string &) –> void

property tag_map_¶

property tags_¶

tellp(self: pyrosetta.rosetta.std.ostringstream) → pyrosetta.rosetta.std.fpos___mbstate_t_t¶: C++: std::basic_ostream<char, std::char_traits<char> >::tellp() –> class std::fpos<__mbstate_t>

write(self: pyrosetta.rosetta.std.ostringstream, __s: str, __n: int) → pyrosetta.rosetta.std.ostream¶: C++: std::basic_ostream<char, std::char_traits<char> >::write(const char *, long) –> std::ostream &

write_summary(self: pyrosetta.rosetta.protocols.frag_picker.QuotaDebug) → None¶: C++: protocols::frag_picker::QuotaDebug::write_summary() –> void

class pyrosetta.rosetta.protocols.frag_picker.SidechainContactDistCutoff¶

Bases: 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.TorsionBinIO¶

Bases: pybind11_object

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

matrix(self: pyrosetta.rosetta.protocols.frag_picker.TorsionBinIO) → pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t¶: C++: protocols::frag_picker::TorsionBinIO::matrix() const –> const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &

nrows(self: pyrosetta.rosetta.protocols.frag_picker.TorsionBinIO) → int¶: C++: protocols::frag_picker::TorsionBinIO::nrows() const –> unsigned long

prof_row(self: pyrosetta.rosetta.protocols.frag_picker.TorsionBinIO, idx: int) → pyrosetta.rosetta.utility.vector1_double¶: C++: protocols::frag_picker::TorsionBinIO::prof_row(const unsigned long) const –> const class utility::vector1<double, class std::allocator<double> > &

read(self: pyrosetta.rosetta.protocols.frag_picker.TorsionBinIO, input: pyrosetta.rosetta.std.istream) → None¶: C++: protocols::frag_picker::TorsionBinIO::read(std::istream &) –> void

write(self: pyrosetta.rosetta.protocols.frag_picker.TorsionBinIO, output: pyrosetta.rosetta.std.ostream) → None¶: C++: protocols::frag_picker::TorsionBinIO::write(std::ostream &) –> void

class pyrosetta.rosetta.protocols.frag_picker.VallChunk¶

Bases: 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.

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

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

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_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_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(std::string, 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<std::string, class std::allocator<std::string > > &) –> unsigned long

vallChunksFromLibrary(*args, **kwargs)¶

Overloaded function.

vallChunksFromLibrary(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, filename: str) -> int
vallChunksFromLibrary(self: pyrosetta.rosetta.protocols.frag_picker.VallProvider, filename: str, startline: int) -> int
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 std::string &, 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 std::string &) –> unsigned long

class pyrosetta.rosetta.protocols.frag_picker.VallResidue¶

Bases: pybind11_object

class for managing a line of the Vall fragment library

aa(*args, **kwargs)¶

Overloaded function.

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

one letter amino acid code

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

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.

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

b factor average for backbone

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

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.

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

x-coordinate of C-beta

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

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.

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

y-coordinate of C-beta

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

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.

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

z-coordinate of C-beta

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

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.

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

x-coordinate of centroid

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

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.

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

y-coordinate of centroid

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

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.

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

z-coordinate of centroid

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

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.

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

all-atom residue depth

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

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.

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

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

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 &

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

key(*args, **kwargs)¶

Overloaded function.

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

sets the key id

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

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.

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

number of alignments

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

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.

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

omega backbone torsion in degrees

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

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.

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

phi backbone torsion in degrees

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

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.

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> > &

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.

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> > &

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.

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

psi backbone torsion in degrees

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

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.

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

residue sequence number in source

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

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.

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

solvent accessible area

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

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.

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

one letter secondary structure code

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

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.

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

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.

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

x-coordinate of C-alpha

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

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.

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

y-coordinate of C-alpha

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

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.

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

z-coordinate of C-alpha

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

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

pyrosetta.rosetta.protocols.frag_picker.run_command(command: str) → None¶: C++: protocols::frag_picker::run_command(const std::string &) –> void

pyrosetta.rosetta.protocols.frag_picker.sa_faraggi_max(aa: str) → float¶: C++: protocols::frag_picker::sa_faraggi_max(char) –> double