sequence

Bindings for core::sequence namespace

class pyrosetta.rosetta.core.sequence.ABEGO

Bases: pybind11_object

abego elments

add_line(self: pyrosetta.rosetta.core.sequence.ABEGO, slope: float, intercept: float, region: bool) → None

C++: core::sequence::ABEGO::add_line(const double, const double, const bool) –> void

check_rama(self: pyrosetta.rosetta.core.sequence.ABEGO, phi: float, psi: float, omega: float) → bool

check input torsion angle are in a given abego region

C++: core::sequence::ABEGO::check_rama(const double &, const double &, const double &) –> bool

check_rama2(self: pyrosetta.rosetta.core.sequence.ABEGO, phi: float, psi: float) → bool

check input torsion angle are in a given abego region

C++: core::sequence::ABEGO::check_rama2(const double &, const double &) –> bool

cis_omega(self: pyrosetta.rosetta.core.sequence.ABEGO) → bool

C++: core::sequence::ABEGO::cis_omega() –> bool

name(self: pyrosetta.rosetta.core.sequence.ABEGO) → str

C++: core::sequence::ABEGO::name() –> char

phi_max(self: pyrosetta.rosetta.core.sequence.ABEGO) → float

C++: core::sequence::ABEGO::phi_max() –> double

phi_min(self: pyrosetta.rosetta.core.sequence.ABEGO) → float

C++: core::sequence::ABEGO::phi_min() –> double

psi_max(self: pyrosetta.rosetta.core.sequence.ABEGO) → float

C++: core::sequence::ABEGO::psi_max() –> double

psi_min(self: pyrosetta.rosetta.core.sequence.ABEGO) → float

C++: core::sequence::ABEGO::psi_min() –> double

class pyrosetta.rosetta.core.sequence.ABEGOManager

Bases: pybind11_object

manager for abego

alllevel(self: pyrosetta.rosetta.core.sequence.ABEGOManager) → int

all output level in current setup

C++: core::sequence::ABEGOManager::alllevel() –> unsigned long

assign(self: pyrosetta.rosetta.core.sequence.ABEGOManager, : pyrosetta.rosetta.core.sequence.ABEGOManager) → pyrosetta.rosetta.core.sequence.ABEGOManager

C++: core::sequence::ABEGOManager::operator=(const class core::sequence::ABEGOManager &) –> class core::sequence::ABEGOManager &

base5index2symbolString(self: pyrosetta.rosetta.core.sequence.ABEGOManager, base5index: int, length: int) → str

transform abego string to abego base5 index

C++: core::sequence::ABEGOManager::base5index2symbolString(unsigned long, unsigned long) –> std::string

check_rama(self: pyrosetta.rosetta.core.sequence.ABEGOManager, symbol: str, phi: float, psi: float, omega: float) → bool

check input torsion angle are in a given abego region

C++: core::sequence::ABEGOManager::check_rama(const char &, const double &, const double &, const double &) –> bool

get_abego_string(self: pyrosetta.rosetta.core.sequence.ABEGOManager, abego: pyrosetta.rosetta.utility.vector1_std_string) → str

get abego string

C++: core::sequence::ABEGOManager::get_abego_string(class utility::vector1<std::string, class std::allocator<std::string > >) –> std::string

get_symbols(*args, **kwargs)

Overloaded function.

1. get_symbols(self: pyrosetta.rosetta.core.sequence.ABEGOManager, pose: core::pose::Pose) -> pyrosetta.rosetta.utility.vector1_std_string

2. get_symbols(self: pyrosetta.rosetta.core.sequence.ABEGOManager, pose: core::pose::Pose, level: int) -> pyrosetta.rosetta.utility.vector1_std_string

get abego sequence from pose

C++: core::sequence::ABEGOManager::get_symbols(const class core::pose::Pose &, const unsigned long) –> class utility::vector1<std::string, class std::allocator<std::string > >

3. get_symbols(self: pyrosetta.rosetta.core.sequence.ABEGOManager, pose: core::pose::Pose, begin: int, end: int, level: int) -> pyrosetta.rosetta.utility.vector1_std_string

get abego sequence from pose

C++: core::sequence::ABEGOManager::get_symbols(const class core::pose::Pose &, const unsigned long, const unsigned long, const unsigned long) –> class utility::vector1<std::string, class std::allocator<std::string > >

index2symbol(self: pyrosetta.rosetta.core.sequence.ABEGOManager, idx: int) → str

transform abego index to symbol

C++: core::sequence::ABEGOManager::index2symbol(const unsigned long &) –> char

initialize(self: pyrosetta.rosetta.core.sequence.ABEGOManager) → None

initialize

C++: core::sequence::ABEGOManager::initialize() –> void

symbol2index(self: pyrosetta.rosetta.core.sequence.ABEGOManager, symbol: str) → int

transform abego symbol to index

C++: core::sequence::ABEGOManager::symbol2index(const char &) –> unsigned long

symbolString2base5index(self: pyrosetta.rosetta.core.sequence.ABEGOManager, symbolString: str) → int

transform abego symbol string to base5 index

C++: core::sequence::ABEGOManager::symbolString2base5index(std::string) –> unsigned long

torsion2index(*args, **kwargs)

Overloaded function.

1. torsion2index(self: pyrosetta.rosetta.core.sequence.ABEGOManager, phi: float, psi: float, omega: float) -> int

2. torsion2index(self: pyrosetta.rosetta.core.sequence.ABEGOManager, phi: float, psi: float, omega: float, level: int) -> int

get abego index from torsion angles

C++: core::sequence::ABEGOManager::torsion2index(const double, const double, const double, const unsigned long) –> unsigned long

torsion2index_level1(self: pyrosetta.rosetta.core.sequence.ABEGOManager, phi: float, psi: float, omega: float) → int

get abego index from torsion angles at level 1

C++: core::sequence::ABEGOManager::torsion2index_level1(const double, const double, const double) –> unsigned long

torsion2index_level2(self: pyrosetta.rosetta.core.sequence.ABEGOManager, phi: float, psi: float, omega: float) → int

get abego index from torsion angles at level 2

C++: core::sequence::ABEGOManager::torsion2index_level2(const double, const double, const double) –> unsigned long

torsion2index_level3(self: pyrosetta.rosetta.core.sequence.ABEGOManager, phi: float, psi: float, omega: float) → int

get abego index from torsion angles at level 3

C++: core::sequence::ABEGOManager::torsion2index_level3(const double, const double, const double) –> unsigned long

torsion2index_level4(self: pyrosetta.rosetta.core.sequence.ABEGOManager, phi: float, psi: float, omega: float) → int

get abego index from torsion angles at level 3

C++: core::sequence::ABEGOManager::torsion2index_level4(const double, const double, const double) –> unsigned long

total_number_abego(self: pyrosetta.rosetta.core.sequence.ABEGOManager) → int

total number of abego definition

C++: core::sequence::ABEGOManager::total_number_abego() –> unsigned long

class pyrosetta.rosetta.core.sequence.AlignMove

Bases: pybind11_object

Members:

diagonal

left

above

end

above = <AlignMove.above: 3>

diagonal = <AlignMove.diagonal: 1>

end = <AlignMove.end: 4>

left = <AlignMove.left: 2>

property name

property value

class pyrosetta.rosetta.core.sequence.Aligner

Bases: pybind11_object

align(self: pyrosetta.rosetta.core.sequence.Aligner, seq_y: core::sequence::Sequence, seq_x: core::sequence::Sequence, ss: core::sequence::ScoringScheme) → core::sequence::SequenceAlignment

C++: core::sequence::Aligner::align(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::ScoringScheme>) –> class core::sequence::SequenceAlignment

assign(self: pyrosetta.rosetta.core.sequence.Aligner, : pyrosetta.rosetta.core.sequence.Aligner) → pyrosetta.rosetta.core.sequence.Aligner

C++: core::sequence::Aligner::operator=(const class core::sequence::Aligner &) –> class core::sequence::Aligner &

traceback(self: pyrosetta.rosetta.core.sequence.Aligner, seq_x: core::sequence::Sequence, seq_y: core::sequence::Sequence, matrix: pyrosetta.rosetta.core.sequence.DP_Matrix, start: pyrosetta.rosetta.core.sequence.Cell) → core::sequence::SequenceAlignment

C++: core::sequence::Aligner::traceback(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, class core::sequence::DP_Matrix, class std::shared_ptr<class core::sequence::Cell>) –> class core::sequence::SequenceAlignment

validate_input(self: pyrosetta.rosetta.core.sequence.Aligner, seq_y: core::sequence::Sequence, seq_x: core::sequence::Sequence, ss: core::sequence::ScoringScheme) → None

C++: core::sequence::Aligner::validate_input(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::ScoringScheme>) –> void

class pyrosetta.rosetta.core.sequence.AlignerFactory

Bases: pybind11_object

static get_aligner(type: str) → pyrosetta.rosetta.core.sequence.Aligner

returns an AlignerOP

C++: core::sequence::AlignerFactory::get_aligner(const std::string &) –> class std::shared_ptr<class core::sequence::Aligner>

class pyrosetta.rosetta.core.sequence.AnnotatedSequence

Bases: pybind11_object

aa(self: pyrosetta.rosetta.core.sequence.AnnotatedSequence, seqpos: int) → pyrosetta.rosetta.core.chemical.AA

C++: core::sequence::AnnotatedSequence::aa(unsigned long) const –> enum core::chemical::AA

assign(*args, **kwargs)

Overloaded function.

1. assign(self: pyrosetta.rosetta.core.sequence.AnnotatedSequence, : str) -> None

C++: core::sequence::AnnotatedSequence::operator=(const std::string &) –> void

2. assign(self: pyrosetta.rosetta.core.sequence.AnnotatedSequence, other: pyrosetta.rosetta.core.sequence.AnnotatedSequence) -> pyrosetta.rosetta.core.sequence.AnnotatedSequence

C++: core::sequence::AnnotatedSequence::operator=(const class core::sequence::AnnotatedSequence &) –> class core::sequence::AnnotatedSequence &

is_patched(self: pyrosetta.rosetta.core.sequence.AnnotatedSequence, seqpos: int) → bool

C++: core::sequence::AnnotatedSequence::is_patched(unsigned long) const –> bool

length(self: pyrosetta.rosetta.core.sequence.AnnotatedSequence) → int

C++: core::sequence::AnnotatedSequence::length() const –> unsigned long

one_letter(self: pyrosetta.rosetta.core.sequence.AnnotatedSequence, seqpos: int) → str

C++: core::sequence::AnnotatedSequence::one_letter(unsigned long) const –> char

one_letter_sequence(self: pyrosetta.rosetta.core.sequence.AnnotatedSequence) → str

C++: core::sequence::AnnotatedSequence::one_letter_sequence() const –> std::string

patch_str(self: pyrosetta.rosetta.core.sequence.AnnotatedSequence, seqpos: int) → str

C++: core::sequence::AnnotatedSequence::patch_str(unsigned long) const –> std::string

class pyrosetta.rosetta.core.sequence.Blosum62Map

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.sequence.Blosum62Map, : pyrosetta.rosetta.core.sequence.Blosum62Map) → pyrosetta.rosetta.core.sequence.Blosum62Map

C++: core::sequence::Blosum62Map::operator=(const struct core::sequence::Blosum62Map &) –> struct core::sequence::Blosum62Map &

score_for_aa_pair(*args, **kwargs)

Overloaded function.

1. score_for_aa_pair(self: pyrosetta.rosetta.core.sequence.Blosum62Map, name1s: Tuple[str, str]) -> int

C++: core::sequence::Blosum62Map::score_for_aa_pair(struct std::pair<char, char>) const –> int

2. score_for_aa_pair(self: pyrosetta.rosetta.core.sequence.Blosum62Map, aa1: str, aa2: str) -> int

C++: core::sequence::Blosum62Map::score_for_aa_pair(char, char) const –> int

class pyrosetta.rosetta.core.sequence.Cell

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.sequence.Cell, c: pyrosetta.rosetta.core.sequence.Cell) → pyrosetta.rosetta.core.sequence.Cell

C++: core::sequence::Cell::operator=(const class core::sequence::Cell &) –> class core::sequence::Cell &

came_from(*args, **kwargs)

Overloaded function.

1. came_from(self: pyrosetta.rosetta.core.sequence.Cell) -> pyrosetta.rosetta.core.sequence.AlignMove

C++: core::sequence::Cell::came_from() –> enum core::sequence::AlignMove

2. came_from(self: pyrosetta.rosetta.core.sequence.Cell, type: pyrosetta.rosetta.core.sequence.AlignMove) -> None

C++: core::sequence::Cell::came_from(const enum core::sequence::AlignMove &) –> void

next(*args, **kwargs)

Overloaded function.

1. next(self: pyrosetta.rosetta.core.sequence.Cell, n: pyrosetta.rosetta.core.sequence.Cell) -> None

C++: core::sequence::Cell::next(class std::shared_ptr<class core::sequence::Cell>) –> void

2. next(self: pyrosetta.rosetta.core.sequence.Cell) -> pyrosetta.rosetta.core.sequence.Cell

C++: core::sequence::Cell::next() –> class std::shared_ptr<class core::sequence::Cell>

score(*args, **kwargs)

Overloaded function.

1. score(self: pyrosetta.rosetta.core.sequence.Cell, score: float) -> None

C++: core::sequence::Cell::score(const double &) –> void

2. score(self: pyrosetta.rosetta.core.sequence.Cell) -> float

C++: core::sequence::Cell::score() const –> double

x(*args, **kwargs)

Overloaded function.

1. x(self: pyrosetta.rosetta.core.sequence.Cell, s: int) -> None

C++: core::sequence::Cell::x(const unsigned long &) –> void

2. x(self: pyrosetta.rosetta.core.sequence.Cell) -> int

C++: core::sequence::Cell::x() –> unsigned long

y(*args, **kwargs)

Overloaded function.

1. y(self: pyrosetta.rosetta.core.sequence.Cell, s: int) -> None

C++: core::sequence::Cell::y(const unsigned long &) –> void

2. y(self: pyrosetta.rosetta.core.sequence.Cell) -> int

C++: core::sequence::Cell::y() –> unsigned long

class pyrosetta.rosetta.core.sequence.CharPairHash

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.sequence.CharPairHash, : pyrosetta.rosetta.core.sequence.CharPairHash) → pyrosetta.rosetta.core.sequence.CharPairHash

C++: core::sequence::CharPairHash::operator=(const struct core::sequence::CharPairHash &) –> struct core::sequence::CharPairHash &

class pyrosetta.rosetta.core.sequence.ChemicalShiftScoringScheme

Bases: ScoringScheme

assign(self: pyrosetta.rosetta.core.sequence.ChemicalShiftScoringScheme, : pyrosetta.rosetta.core.sequence.ChemicalShiftScoringScheme) → pyrosetta.rosetta.core.sequence.ChemicalShiftScoringScheme

C++: core::sequence::ChemicalShiftScoringScheme::operator=(const class core::sequence::ChemicalShiftScoringScheme &) –> class core::sequence::ChemicalShiftScoringScheme &

clone(self: pyrosetta.rosetta.core.sequence.ChemicalShiftScoringScheme) → pyrosetta.rosetta.core.sequence.ScoringScheme

C++: core::sequence::ChemicalShiftScoringScheme::clone() const –> class std::shared_ptr<class core::sequence::ScoringScheme>

gap_extend(*args, **kwargs)

Overloaded function.

1. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend() const –> double

2. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_extend: float) -> None

Sets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend(const double) –> void

gap_open(*args, **kwargs)

Overloaded function.

1. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open() const –> double

2. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_open: float) -> None

Sets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open(const double) –> void

is_good(self: pyrosetta.rosetta.core.sequence.ScoringScheme, num: float) → bool

C++: core::sequence::ScoringScheme::is_good(const double &) –> bool

read_data(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.io.izstream) → None

C++: core::sequence::ScoringScheme::read_data(class utility::io::izstream &) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.file.FileName) → None

Initialize from a file.

C++: core::sequence::ScoringScheme::read_from_file(const class utility::file::FileName &) –> void

score(self: pyrosetta.rosetta.core.sequence.ChemicalShiftScoringScheme, seq1: core::sequence::Sequence, seq2: core::sequence::Sequence, pos1: int, pos2: int) → float

C++: core::sequence::ChemicalShiftScoringScheme::score(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, unsigned long, unsigned long) –> double

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> str

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type() const –> std::string

2. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme, new_type: str) -> None

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type(std::string) –> void

unimplemented_method_error(self: pyrosetta.rosetta.core.sequence.ScoringScheme, method_name: str) → None

Utility method for producing useful error messages and exiting

from program. Declared const which is funny, because exiting the program certainly changes the state of this object! This might be replaced with exception handling if we ever start using those.

C++: core::sequence::ScoringScheme::unimplemented_method_error(const std::string &) const –> void

class pyrosetta.rosetta.core.sequence.ChemicalShiftSequence

Bases: SequenceProfile

alphabet(*args, **kwargs)

Overloaded function.

1. alphabet(self: pyrosetta.rosetta.core.sequence.ChemicalShiftSequence) -> pyrosetta.rosetta.utility.vector1_std_string

Return the alphabet used by this sequence profile. This is an

N-dimensional vector1 where N is the width of the profile, and the ith entry of any row in the profile represents the probability of ith character at that row in the sequence.

C++: core::sequence::ChemicalShiftSequence::alphabet() const –> class utility::vector1<std::string, class std::allocator<std::string > >

2. alphabet(self: pyrosetta.rosetta.core.sequence.ChemicalShiftSequence, new_alphabet: pyrosetta.rosetta.utility.vector1_std_string) -> None

C++: core::sequence::ChemicalShiftSequence::alphabet(class utility::vector1<std::string, class std::allocator<std::string > >) –> void

append_char(self: pyrosetta.rosetta.core.sequence.Sequence, new_char: str) → None

Append a character

C++: core::sequence::Sequence::append_char(char) –> void

append_gap(self: pyrosetta.rosetta.core.sequence.Sequence) → None

Append a gap

C++: core::sequence::Sequence::append_gap() –> void

assign(self: pyrosetta.rosetta.core.sequence.ChemicalShiftSequence, : pyrosetta.rosetta.core.sequence.ChemicalShiftSequence) → pyrosetta.rosetta.core.sequence.ChemicalShiftSequence

C++: core::sequence::ChemicalShiftSequence::operator=(const class core::sequence::ChemicalShiftSequence &) –> class core::sequence::ChemicalShiftSequence &

at(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → str

C++: core::sequence::Sequence::at(unsigned long) const –> char

clone(self: pyrosetta.rosetta.core.sequence.ChemicalShiftSequence) → pyrosetta.rosetta.core.sequence.Sequence

Returns an owning pointer to a new ChemicalShiftSequence object,

with data that is a deep copy of the information in this object.

C++: core::sequence::ChemicalShiftSequence::clone() const –> class std::shared_ptr<class core::sequence::Sequence>

convert_profile_to_probs(*args, **kwargs)

Overloaded function.

1. convert_profile_to_probs(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> None

2. convert_profile_to_probs(self: pyrosetta.rosetta.core.sequence.SequenceProfile, temp: float) -> None

Use boltzman scaling on a per-residue basis to convert the current profile values to probabilities ( range 0.0-1.0 )

C++: core::sequence::SequenceProfile::convert_profile_to_probs(double) –> void

delete_position(self: pyrosetta.rosetta.core.sequence.SequenceProfile, pos: int) → None

Deletes the given position from the Sequence and shifts

everything else back by one.

C++: core::sequence::SequenceProfile::delete_position(unsigned long) –> void

gap_char(*args, **kwargs)

Overloaded function.

1. gap_char(self: pyrosetta.rosetta.core.sequence.Sequence, gap_char: str) -> None

sets gap_char to the given value.

C++: core::sequence::Sequence::gap_char(char) –> void

2. gap_char(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the character used to represent a gap for this object.

C++: core::sequence::Sequence::gap_char() const –> char

generate_from_sequence(*args, **kwargs)

Overloaded function.

1. generate_from_sequence(self: pyrosetta.rosetta.core.sequence.SequenceProfile, seq: pyrosetta.rosetta.core.sequence.Sequence) -> None

2. generate_from_sequence(self: pyrosetta.rosetta.core.sequence.SequenceProfile, seq: pyrosetta.rosetta.core.sequence.Sequence, matrix: str) -> None

Generate the profile matrix from a sequence and a given substitution matrix

C++: core::sequence::SequenceProfile::generate_from_sequence(const class core::sequence::Sequence &, std::string) –> void

global_auto_rescale(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → None

Use linear rescaling (with a fixed zero) to fit the values within the range -1.0 to 1.0

C++: core::sequence::SequenceProfile::global_auto_rescale() –> void

id(*args, **kwargs)

Overloaded function.

1. id(self: pyrosetta.rosetta.core.sequence.Sequence, new_id: str) -> None

sets id to the given value.

C++: core::sequence::Sequence::id(std::string) –> void

2. id(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the id of this object.

C++: core::sequence::Sequence::id() const –> std::string

insert_char(self: pyrosetta.rosetta.core.sequence.SequenceProfile, pos: int, new_char: str) → None

Inserts a character at the given position.

C++: core::sequence::SequenceProfile::insert_char(unsigned long, char) –> void

insert_gap(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → None

Inserts a gap at the given position, where insert_gap( 0 )

inserts the character at the beginning of the sequence, and insert_gap( length() ) inserts the character at the end of the sequence.

C++: core::sequence::Sequence::insert_gap(unsigned long) –> void

is_gap(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → bool

Returns true if this position in the sequence represents a gap,

returns false otherwise.

C++: core::sequence::Sequence::is_gap(unsigned long) const –> bool

length(self: pyrosetta.rosetta.core.sequence.Sequence) → int

Returns the number of characters in this object.

C++: core::sequence::Sequence::length() const –> unsigned long

negative_better(*args, **kwargs)

Overloaded function.

1. negative_better(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> bool

Returns true if negative values are better identities.

The “default” use case is for storing log likelihood values where positive is better. If you’re using this class to store energy-like values, set negative_better to true.

C++: core::sequence::SequenceProfile::negative_better() const –> bool

2. negative_better(self: pyrosetta.rosetta.core.sequence.SequenceProfile, negbet: bool) -> None

Set whether negative identities are better.

C++: core::sequence::SequenceProfile::negative_better(bool) –> void

occurrence_data(*args, **kwargs)

Overloaded function.

1. occurrence_data(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t

Returns the 2D vector1 of Real values of the probabilties of each aa.

C++: core::sequence::SequenceProfile::occurrence_data() const –> const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &

2. occurrence_data(self: pyrosetta.rosetta.core.sequence.SequenceProfile, new_occurrence_data: pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t) -> None

Sets the 2D vector1 of Real values of the probabilties of each aa.

C++: core::sequence::SequenceProfile::occurrence_data(const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &) –> void

probability_row(self: pyrosetta.rosetta.core.sequence.SequenceProfile, pos: int) → pyrosetta.rosetta.utility.vector1_double

C++: core::sequence::SequenceProfile::probability_row(unsigned long) const –> const class utility::vector1<double, class std::allocator<double> > &

probabilty_row(self: pyrosetta.rosetta.core.sequence.SequenceProfile, new_prob_row: pyrosetta.rosetta.utility.vector1_double, pos: int) → None

C++: core::sequence::SequenceProfile::probabilty_row(const class utility::vector1<double, class std::allocator<double> > &, unsigned long) –> void

prof_row(*args, **kwargs)

Overloaded function.

1. prof_row(self: pyrosetta.rosetta.core.sequence.SequenceProfile, pos: int) -> pyrosetta.rosetta.utility.vector1_double

Returns the vector1 of values at this position.

C++: core::sequence::SequenceProfile::prof_row(unsigned long) const –> const class utility::vector1<double, class std::allocator<double> > &

2. prof_row(self: pyrosetta.rosetta.core.sequence.SequenceProfile, new_prof_row: pyrosetta.rosetta.utility.vector1_double, pos: int) -> None

Sets the 1D vector1 of Real values representing this profile at pos X.

C++: core::sequence::SequenceProfile::prof_row(const class utility::vector1<double, class std::allocator<double> > &, unsigned long) –> void

profile(*args, **kwargs)

Overloaded function.

1. profile(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t

Returns the 2D vector1 of Real values representing this profile.

C++: core::sequence::SequenceProfile::profile() const –> const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &

2. profile(self: pyrosetta.rosetta.core.sequence.SequenceProfile, new_profile: pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t) -> None

Sets the 2D vector1 of Real values representing this profile.

C++: core::sequence::SequenceProfile::profile(const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &) –> void

read_data(self: pyrosetta.rosetta.core.sequence.Sequence, in: pyrosetta.rosetta.std.istream) → None

Initializes the information in this sequence from the given

std::istream. The istream should yield three pieces of information in the following order: - id - start - sequence

C++: core::sequence::Sequence::read_data(std::istream &) –> void

read_from_binary_chk(self: pyrosetta.rosetta.core.sequence.SequenceProfile, fn: pyrosetta.rosetta.utility.file.FileName) → None

Read profile matrix from the given filename in the legacy BLAST binary format

C++: core::sequence::SequenceProfile::read_from_binary_chk(const class utility::file::FileName &) –> void

read_from_checkpoint(*args, **kwargs)

Overloaded function.

1. read_from_checkpoint(self: pyrosetta.rosetta.core.sequence.SequenceProfile, fn: pyrosetta.rosetta.utility.file.FileName) -> None

2. read_from_checkpoint(self: pyrosetta.rosetta.core.sequence.SequenceProfile, fn: pyrosetta.rosetta.utility.file.FileName, negative_better: bool) -> None

Read profile matrix from the given filename using the NNMAKE

.checkpoint format. For compatability, negative_better defaults to true. Set manually if necessary.

C++: core::sequence::SequenceProfile::read_from_checkpoint(const class utility::file::FileName &, bool) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.ChemicalShiftSequence, fn: pyrosetta.rosetta.utility.file.FileName) → None

Read an profile matrix from the given filename using the

2nd_inCS.tab format.

C++: core::sequence::ChemicalShiftSequence::read_from_file(const class utility::file::FileName &) –> void

replace_char(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int, new_char: str) → None

C++: core::sequence::Sequence::replace_char(unsigned long, char) –> void

rescale(*args, **kwargs)

Overloaded function.

1. rescale(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> None

2. rescale(self: pyrosetta.rosetta.core.sequence.SequenceProfile, factor: float) -> None

Multiply all profile weights by factor

C++: core::sequence::SequenceProfile::rescale(double) –> void

resnum(self: pyrosetta.rosetta.core.sequence.Sequence, idx: int) → int

Returns the index of the given sequence position, which is the

position in the sequence minus any gaps that occur earlier in the sequence. For example, if the sequence is —AT, resnum(5) will return 2. Returns 0 for unaligned positions.

C++: core::sequence::Sequence::resnum(unsigned long) const –> unsigned long

sequence(*args, **kwargs)

Overloaded function.

1. sequence(self: pyrosetta.rosetta.core.sequence.Sequence, sequence: str) -> None

sets sequence to the given value.

C++: core::sequence::Sequence::sequence(std::string) –> void

2. sequence(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the full sequence, which may include gaps.

C++: core::sequence::Sequence::sequence() const –> std::string

sigma(self: pyrosetta.rosetta.core.sequence.ChemicalShiftSequence, : int, idx: int) → float

C++: core::sequence::ChemicalShiftSequence::sigma(unsigned long, unsigned long) –> double

size(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → int

C++: core::sequence::SequenceProfile::size() const –> unsigned long

spacer_positions(*args, **kwargs)

Overloaded function.

1. spacer_positions(self: pyrosetta.rosetta.core.sequence.Sequence, spacer_positions: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

sets spacer_positions to the given value.

C++: core::sequence::Sequence::spacer_positions(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

2. spacer_positions(self: pyrosetta.rosetta.core.sequence.Sequence) -> pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the spacer positions (chain breaks, e.g., from spaces or commas in original sequence text)

C++: core::sequence::Sequence::spacer_positions() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

start(*args, **kwargs)

Overloaded function.

1. start(self: pyrosetta.rosetta.core.sequence.Sequence, new_start: int) -> None

sets starting index to the given value.

C++: core::sequence::Sequence::start(unsigned long) –> void

2. start(self: pyrosetta.rosetta.core.sequence.Sequence) -> int

Returns the start of this object.

C++: core::sequence::Sequence::start() const –> unsigned long

temp(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → float

returns the temperature used in computing profile probabilities

C++: core::sequence::SequenceProfile::temp() const –> double

to_string(self: pyrosetta.rosetta.core.sequence.Sequence) → str

C++: core::sequence::Sequence::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → str

C++: core::sequence::SequenceProfile::type() const –> std::string

ungapped_length(self: pyrosetta.rosetta.core.sequence.Sequence) → int

Returns the number of characters in this object, ignoring gaps.

C++: core::sequence::Sequence::ungapped_length() const –> unsigned long

ungapped_sequence(self: pyrosetta.rosetta.core.sequence.Sequence) → str

Returns the string representing this sequence without gaps.

C++: core::sequence::Sequence::ungapped_sequence() const –> std::string

width(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → int

Returns the number of distinct values at each position in this

profile.

C++: core::sequence::SequenceProfile::width() const –> unsigned long

class pyrosetta.rosetta.core.sequence.ChemicalShiftSequenceCreator

Bases: SequenceCreator

assign(self: pyrosetta.rosetta.core.sequence.ChemicalShiftSequenceCreator, : pyrosetta.rosetta.core.sequence.ChemicalShiftSequenceCreator) → pyrosetta.rosetta.core.sequence.ChemicalShiftSequenceCreator

C++: core::sequence::ChemicalShiftSequenceCreator::operator=(const class core::sequence::ChemicalShiftSequenceCreator &) –> class core::sequence::ChemicalShiftSequenceCreator &

create_sequence(self: pyrosetta.rosetta.core.sequence.ChemicalShiftSequenceCreator) → core::sequence::Sequence

C++: core::sequence::ChemicalShiftSequenceCreator::create_sequence() const –> class std::shared_ptr<class core::sequence::Sequence>

keyname(self: pyrosetta.rosetta.core.sequence.ChemicalShiftSequenceCreator) → str

C++: core::sequence::ChemicalShiftSequenceCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.sequence.CompassScoringScheme

Bases: ScoringScheme

assign(self: pyrosetta.rosetta.core.sequence.CompassScoringScheme, : pyrosetta.rosetta.core.sequence.CompassScoringScheme) → pyrosetta.rosetta.core.sequence.CompassScoringScheme

C++: core::sequence::CompassScoringScheme::operator=(const class core::sequence::CompassScoringScheme &) –> class core::sequence::CompassScoringScheme &

clone(self: pyrosetta.rosetta.core.sequence.CompassScoringScheme) → pyrosetta.rosetta.core.sequence.ScoringScheme

C++: core::sequence::CompassScoringScheme::clone() const –> class std::shared_ptr<class core::sequence::ScoringScheme>

gap_extend(*args, **kwargs)

Overloaded function.

1. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend() const –> double

2. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_extend: float) -> None

Sets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend(const double) –> void

gap_open(*args, **kwargs)

Overloaded function.

1. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open() const –> double

2. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_open: float) -> None

Sets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open(const double) –> void

is_good(self: pyrosetta.rosetta.core.sequence.ScoringScheme, num: float) → bool

C++: core::sequence::ScoringScheme::is_good(const double &) –> bool

read_data(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.io.izstream) → None

C++: core::sequence::ScoringScheme::read_data(class utility::io::izstream &) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.file.FileName) → None

Initialize from a file.

C++: core::sequence::ScoringScheme::read_from_file(const class utility::file::FileName &) –> void

score(self: pyrosetta.rosetta.core.sequence.CompassScoringScheme, seq1: pyrosetta.rosetta.core.sequence.Sequence, seq2: pyrosetta.rosetta.core.sequence.Sequence, pos1: int, pos2: int) → float

C++: core::sequence::CompassScoringScheme::score(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, unsigned long, unsigned long) –> double

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> str

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type() const –> std::string

2. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme, new_type: str) -> None

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type(std::string) –> void

unimplemented_method_error(self: pyrosetta.rosetta.core.sequence.ScoringScheme, method_name: str) → None

Utility method for producing useful error messages and exiting

from program. Declared const which is funny, because exiting the program certainly changes the state of this object! This might be replaced with exception handling if we ever start using those.

C++: core::sequence::ScoringScheme::unimplemented_method_error(const std::string &) const –> void

class pyrosetta.rosetta.core.sequence.CompositeScoringScheme

Bases: ScoringScheme

add_scoring_scheme(self: pyrosetta.rosetta.core.sequence.CompositeScoringScheme, scheme: pyrosetta.rosetta.core.sequence.ScoringScheme) → None

C++: core::sequence::CompositeScoringScheme::add_scoring_scheme(class std::shared_ptr<class core::sequence::ScoringScheme>) –> void

assign(self: pyrosetta.rosetta.core.sequence.CompositeScoringScheme, : pyrosetta.rosetta.core.sequence.CompositeScoringScheme) → pyrosetta.rosetta.core.sequence.CompositeScoringScheme

C++: core::sequence::CompositeScoringScheme::operator=(const class core::sequence::CompositeScoringScheme &) –> class core::sequence::CompositeScoringScheme &

clone(self: pyrosetta.rosetta.core.sequence.CompositeScoringScheme) → pyrosetta.rosetta.core.sequence.ScoringScheme

C++: core::sequence::CompositeScoringScheme::clone() const –> class std::shared_ptr<class core::sequence::ScoringScheme>

count(self: pyrosetta.rosetta.core.sequence.CompositeScoringScheme) → int

C++: core::sequence::CompositeScoringScheme::count() const –> unsigned long

gap_extend(*args, **kwargs)

Overloaded function.

1. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend() const –> double

2. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_extend: float) -> None

Sets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend(const double) –> void

gap_open(*args, **kwargs)

Overloaded function.

1. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open() const –> double

2. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_open: float) -> None

Sets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open(const double) –> void

is_good(self: pyrosetta.rosetta.core.sequence.ScoringScheme, num: float) → bool

C++: core::sequence::ScoringScheme::is_good(const double &) –> bool

read_data(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.io.izstream) → None

C++: core::sequence::ScoringScheme::read_data(class utility::io::izstream &) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.CompositeScoringScheme, fn: pyrosetta.rosetta.utility.file.FileName) → None

C++: core::sequence::CompositeScoringScheme::read_from_file(const class utility::file::FileName &) –> void

score(self: pyrosetta.rosetta.core.sequence.CompositeScoringScheme, seq1: pyrosetta.rosetta.core.sequence.Sequence, seq2: pyrosetta.rosetta.core.sequence.Sequence, pos1: int, pos2: int) → float

C++: core::sequence::CompositeScoringScheme::score(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, unsigned long, unsigned long) –> double

scoring_schemes(self: pyrosetta.rosetta.core.sequence.CompositeScoringScheme) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_sequence_ScoringScheme_t

C++: core::sequence::CompositeScoringScheme::scoring_schemes() const –> class utility::vector1<class std::shared_ptr<class core::sequence::ScoringScheme>, class std::allocator<class std::shared_ptr<class core::sequence::ScoringScheme> > >

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> str

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type() const –> std::string

2. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme, new_type: str) -> None

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type(std::string) –> void

unimplemented_method_error(self: pyrosetta.rosetta.core.sequence.ScoringScheme, method_name: str) → None

Utility method for producing useful error messages and exiting

from program. Declared const which is funny, because exiting the program certainly changes the state of this object! This might be replaced with exception handling if we ever start using those.

C++: core::sequence::ScoringScheme::unimplemented_method_error(const std::string &) const –> void

class pyrosetta.rosetta.core.sequence.CompositeSequence

Bases: Sequence

add_sequence(self: pyrosetta.rosetta.core.sequence.CompositeSequence, seq: pyrosetta.rosetta.core.sequence.Sequence) → None

C++: core::sequence::CompositeSequence::add_sequence(class std::shared_ptr<class core::sequence::Sequence>) –> void

append_char(self: pyrosetta.rosetta.core.sequence.Sequence, new_char: str) → None

Append a character

C++: core::sequence::Sequence::append_char(char) –> void

append_gap(self: pyrosetta.rosetta.core.sequence.Sequence) → None

Append a gap

C++: core::sequence::Sequence::append_gap() –> void

assign(self: pyrosetta.rosetta.core.sequence.CompositeSequence, rhs: pyrosetta.rosetta.core.sequence.CompositeSequence) → pyrosetta.rosetta.core.sequence.CompositeSequence

assignment operator.

C++: core::sequence::CompositeSequence::operator=(const class core::sequence::CompositeSequence &) –> class core::sequence::CompositeSequence &

at(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → str

C++: core::sequence::Sequence::at(unsigned long) const –> char

clone(self: pyrosetta.rosetta.core.sequence.CompositeSequence) → pyrosetta.rosetta.core.sequence.Sequence

Returns an owning pointer to a new CompositeSequence object,

with data that is a deep copy of the information in this object.

C++: core::sequence::CompositeSequence::clone() const –> class std::shared_ptr<class core::sequence::Sequence>

delete_position(self: pyrosetta.rosetta.core.sequence.CompositeSequence, pos: int) → None

C++: core::sequence::CompositeSequence::delete_position(unsigned long) –> void

gap_char(*args, **kwargs)

Overloaded function.

1. gap_char(self: pyrosetta.rosetta.core.sequence.Sequence, gap_char: str) -> None

sets gap_char to the given value.

C++: core::sequence::Sequence::gap_char(char) –> void

2. gap_char(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the character used to represent a gap for this object.

C++: core::sequence::Sequence::gap_char() const –> char

id(*args, **kwargs)

Overloaded function.

1. id(self: pyrosetta.rosetta.core.sequence.Sequence, new_id: str) -> None

sets id to the given value.

C++: core::sequence::Sequence::id(std::string) –> void

2. id(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the id of this object.

C++: core::sequence::Sequence::id() const –> std::string

insert_char(self: pyrosetta.rosetta.core.sequence.CompositeSequence, pos: int, new_char: str) → None

C++: core::sequence::CompositeSequence::insert_char(unsigned long, char) –> void

insert_gap(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → None

Inserts a gap at the given position, where insert_gap( 0 )

inserts the character at the beginning of the sequence, and insert_gap( length() ) inserts the character at the end of the sequence.

C++: core::sequence::Sequence::insert_gap(unsigned long) –> void

is_gap(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → bool

Returns true if this position in the sequence represents a gap,

returns false otherwise.

C++: core::sequence::Sequence::is_gap(unsigned long) const –> bool

length(self: pyrosetta.rosetta.core.sequence.CompositeSequence) → int

C++: core::sequence::CompositeSequence::length() const –> unsigned long

n_seqs(self: pyrosetta.rosetta.core.sequence.CompositeSequence) → int

C++: core::sequence::CompositeSequence::n_seqs() const –> unsigned long

read_data(self: pyrosetta.rosetta.core.sequence.Sequence, in: pyrosetta.rosetta.std.istream) → None

Initializes the information in this sequence from the given

std::istream. The istream should yield three pieces of information in the following order: - id - start - sequence

C++: core::sequence::Sequence::read_data(std::istream &) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.Sequence, : pyrosetta.rosetta.utility.file.FileName) → None

initializes this sequence object from a file.

C++: core::sequence::Sequence::read_from_file(const class utility::file::FileName &) –> void

replace_char(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int, new_char: str) → None

C++: core::sequence::Sequence::replace_char(unsigned long, char) –> void

resnum(self: pyrosetta.rosetta.core.sequence.Sequence, idx: int) → int

Returns the index of the given sequence position, which is the

position in the sequence minus any gaps that occur earlier in the sequence. For example, if the sequence is —AT, resnum(5) will return 2. Returns 0 for unaligned positions.

C++: core::sequence::Sequence::resnum(unsigned long) const –> unsigned long

seq(self: pyrosetta.rosetta.core.sequence.CompositeSequence, idx: int) → pyrosetta.rosetta.core.sequence.Sequence

C++: core::sequence::CompositeSequence::seq(unsigned long) const –> class std::shared_ptr<class core::sequence::Sequence>

seqs(self: pyrosetta.rosetta.core.sequence.CompositeSequence) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_sequence_Sequence_t

C++: core::sequence::CompositeSequence::seqs() const –> class utility::vector1<class std::shared_ptr<class core::sequence::Sequence>, class std::allocator<class std::shared_ptr<class core::sequence::Sequence> > >

sequence(*args, **kwargs)

Overloaded function.

1. sequence(self: pyrosetta.rosetta.core.sequence.Sequence, sequence: str) -> None

sets sequence to the given value.

C++: core::sequence::Sequence::sequence(std::string) –> void

2. sequence(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the full sequence, which may include gaps.

C++: core::sequence::Sequence::sequence() const –> std::string

spacer_positions(*args, **kwargs)

Overloaded function.

1. spacer_positions(self: pyrosetta.rosetta.core.sequence.Sequence, spacer_positions: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

sets spacer_positions to the given value.

C++: core::sequence::Sequence::spacer_positions(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

2. spacer_positions(self: pyrosetta.rosetta.core.sequence.Sequence) -> pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the spacer positions (chain breaks, e.g., from spaces or commas in original sequence text)

C++: core::sequence::Sequence::spacer_positions() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

start(*args, **kwargs)

Overloaded function.

1. start(self: pyrosetta.rosetta.core.sequence.Sequence, new_start: int) -> None

sets starting index to the given value.

C++: core::sequence::Sequence::start(unsigned long) –> void

2. start(self: pyrosetta.rosetta.core.sequence.Sequence) -> int

Returns the start of this object.

C++: core::sequence::Sequence::start() const –> unsigned long

to_string(self: pyrosetta.rosetta.core.sequence.CompositeSequence) → str

C++: core::sequence::CompositeSequence::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.sequence.CompositeSequence) → str

C++: core::sequence::CompositeSequence::type() const –> std::string

ungapped_length(self: pyrosetta.rosetta.core.sequence.Sequence) → int

Returns the number of characters in this object, ignoring gaps.

C++: core::sequence::Sequence::ungapped_length() const –> unsigned long

ungapped_sequence(self: pyrosetta.rosetta.core.sequence.Sequence) → str

Returns the string representing this sequence without gaps.

C++: core::sequence::Sequence::ungapped_sequence() const –> std::string

class pyrosetta.rosetta.core.sequence.CompositeSequenceCreator

Bases: SequenceCreator

assign(self: pyrosetta.rosetta.core.sequence.CompositeSequenceCreator, : pyrosetta.rosetta.core.sequence.CompositeSequenceCreator) → pyrosetta.rosetta.core.sequence.CompositeSequenceCreator

C++: core::sequence::CompositeSequenceCreator::operator=(const class core::sequence::CompositeSequenceCreator &) –> class core::sequence::CompositeSequenceCreator &

create_sequence(self: pyrosetta.rosetta.core.sequence.CompositeSequenceCreator) → core::sequence::Sequence

C++: core::sequence::CompositeSequenceCreator::create_sequence() const –> class std::shared_ptr<class core::sequence::Sequence>

keyname(self: pyrosetta.rosetta.core.sequence.CompositeSequenceCreator) → str

C++: core::sequence::CompositeSequenceCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.sequence.DPScoringScheme

Bases: ScoringScheme

assign(self: pyrosetta.rosetta.core.sequence.DPScoringScheme, : pyrosetta.rosetta.core.sequence.DPScoringScheme) → pyrosetta.rosetta.core.sequence.DPScoringScheme

C++: core::sequence::DPScoringScheme::operator=(const class core::sequence::DPScoringScheme &) –> class core::sequence::DPScoringScheme &

clone(self: pyrosetta.rosetta.core.sequence.DPScoringScheme) → pyrosetta.rosetta.core.sequence.ScoringScheme

C++: core::sequence::DPScoringScheme::clone() const –> class std::shared_ptr<class core::sequence::ScoringScheme>

gap_extend(*args, **kwargs)

Overloaded function.

1. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend() const –> double

2. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_extend: float) -> None

Sets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend(const double) –> void

gap_open(*args, **kwargs)

Overloaded function.

1. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open() const –> double

2. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_open: float) -> None

Sets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open(const double) –> void

is_good(self: pyrosetta.rosetta.core.sequence.ScoringScheme, num: float) → bool

C++: core::sequence::ScoringScheme::is_good(const double &) –> bool

read_data(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.io.izstream) → None

C++: core::sequence::ScoringScheme::read_data(class utility::io::izstream &) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.file.FileName) → None

Initialize from a file.

C++: core::sequence::ScoringScheme::read_from_file(const class utility::file::FileName &) –> void

score(self: pyrosetta.rosetta.core.sequence.DPScoringScheme, seq1: pyrosetta.rosetta.core.sequence.Sequence, seq2: pyrosetta.rosetta.core.sequence.Sequence, pos1: int, pos2: int) → float

C++: core::sequence::DPScoringScheme::score(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, unsigned long, unsigned long) –> double

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> str

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type() const –> std::string

2. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme, new_type: str) -> None

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type(std::string) –> void

unimplemented_method_error(self: pyrosetta.rosetta.core.sequence.ScoringScheme, method_name: str) → None

Utility method for producing useful error messages and exiting

from program. Declared const which is funny, because exiting the program certainly changes the state of this object! This might be replaced with exception handling if we ever start using those.

C++: core::sequence::ScoringScheme::unimplemented_method_error(const std::string &) const –> void

class pyrosetta.rosetta.core.sequence.DP_Matrix

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.sequence.DP_Matrix, : pyrosetta.rosetta.core.sequence.DP_Matrix) → pyrosetta.rosetta.core.sequence.DP_Matrix

C++: core::sequence::DP_Matrix::operator=(const class core::sequence::DP_Matrix &) –> class core::sequence::DP_Matrix &

clear(self: pyrosetta.rosetta.core.sequence.DP_Matrix) → None

C++: core::sequence::DP_Matrix::clear() –> void

cols(self: pyrosetta.rosetta.core.sequence.DP_Matrix) → int

C++: core::sequence::DP_Matrix::cols() const –> unsigned long

rows(self: pyrosetta.rosetta.core.sequence.DP_Matrix) → int

C++: core::sequence::DP_Matrix::rows() const –> unsigned long

xlab(*args, **kwargs)

Overloaded function.

1. xlab(self: pyrosetta.rosetta.core.sequence.DP_Matrix, xs: pyrosetta.rosetta.utility.vector1_char) -> None

C++: core::sequence::DP_Matrix::xlab(const class utility::vector1<char, class std::allocator<char> > &) –> void

2. xlab(self: pyrosetta.rosetta.core.sequence.DP_Matrix) -> pyrosetta.rosetta.utility.vector1_char

C++: core::sequence::DP_Matrix::xlab() const –> class utility::vector1<char, class std::allocator<char> >

ylab(*args, **kwargs)

Overloaded function.

1. ylab(self: pyrosetta.rosetta.core.sequence.DP_Matrix, ys: pyrosetta.rosetta.utility.vector1_char) -> None

C++: core::sequence::DP_Matrix::ylab(const class utility::vector1<char, class std::allocator<char> > &) –> void

2. ylab(self: pyrosetta.rosetta.core.sequence.DP_Matrix) -> pyrosetta.rosetta.utility.vector1_char

C++: core::sequence::DP_Matrix::ylab() const –> class utility::vector1<char, class std::allocator<char> >

class pyrosetta.rosetta.core.sequence.DerivedSequenceMapping

Bases: SequenceMapping

This is quite possibly the laziest form of class naming ever. What does the name of this class tell you about it? It’s a SequenceMapping, and it’s derived from SequenceMapping. Oops, it said it twice. What is different about this sequence mapping from the parent class? Who knows! When should you use it? Who knows!</snark>

all_aligned(self: pyrosetta.rosetta.core.id.SequenceMapping) → bool

C++: core::id::SequenceMapping::all_aligned() const –> bool

assign(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping, src: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping) → pyrosetta.rosetta.core.sequence.DerivedSequenceMapping

C++: core::sequence::DerivedSequenceMapping::operator=(const class core::sequence::DerivedSequenceMapping &) –> class core::sequence::DerivedSequenceMapping &

clear(self: pyrosetta.rosetta.core.id.SequenceMapping) → None

C++: core::id::SequenceMapping::clear() –> void

delete_source_residue(self: pyrosetta.rosetta.core.id.SequenceMapping, pos1: int) → None

C++: core::id::SequenceMapping::delete_source_residue(const unsigned long) –> void

delete_target_residue(self: pyrosetta.rosetta.core.id.SequenceMapping, pos: int) → None

C++: core::id::SequenceMapping::delete_target_residue(const unsigned long) –> void

downstream_combine(self: pyrosetta.rosetta.core.id.SequenceMapping, smap_to_add: pyrosetta.rosetta.core.id.SequenceMapping) → None

Apply a B->C mapping to the current A->B mapping to get an A->C mapping

i.e. smap[j] becomes smap_to_add[ smap[j] ]

C++: core::id::SequenceMapping::downstream_combine(const class core::id::SequenceMapping &) –> void

get_corresponding_residue_in_current(self: pyrosetta.rosetta.core.id.SequenceMapping, original_resnum: int) → int

A->B; Get the corresponding (new) resnum (B) from the old (A).

C++: core::id::SequenceMapping::get_corresponding_residue_in_current(unsigned long) const –> unsigned long

static identity(size: int) → pyrosetta.rosetta.core.id.SequenceMapping

Construct an identity mapping, which means that for all positions,

i in seq1 maps to i in seq2.

C++: core::id::SequenceMapping::identity(const unsigned long) –> class core::id::SequenceMapping

insert_aligned_residue(self: pyrosetta.rosetta.core.id.SequenceMapping, pos1: int, pos2: int) → None

C++: core::id::SequenceMapping::insert_aligned_residue(const unsigned long, const unsigned long) –> void

insert_aligned_residue_safe(self: pyrosetta.rosetta.core.id.SequenceMapping, pos1: int, pos2: int) → None

same as insert_aligned_residue, but a couple of extra checks on size1 and size2.

C++: core::id::SequenceMapping::insert_aligned_residue_safe(const unsigned long, const unsigned long) –> void

insert_source_residue(self: pyrosetta.rosetta.core.id.SequenceMapping, pos1: int) → None

C++: core::id::SequenceMapping::insert_source_residue(const unsigned long) –> void

insert_target_residue(self: pyrosetta.rosetta.core.id.SequenceMapping, pos: int) → None

C++: core::id::SequenceMapping::insert_target_residue(const unsigned long) –> void

is_identity(self: pyrosetta.rosetta.core.id.SequenceMapping) → bool

C++: core::id::SequenceMapping::is_identity() const –> bool

is_identity_ignore_gaps(self: pyrosetta.rosetta.core.id.SequenceMapping) → bool

C++: core::id::SequenceMapping::is_identity_ignore_gaps() const –> bool

mapping(*args, **kwargs)

Overloaded function.

1. mapping(self: pyrosetta.rosetta.core.id.SequenceMapping) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: core::id::SequenceMapping::mapping() const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

2. mapping(self: pyrosetta.rosetta.core.id.SequenceMapping, mapping: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: core::id::SequenceMapping::mapping(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

push_back(self: pyrosetta.rosetta.core.id.SequenceMapping, al: int) → None

C++: core::id::SequenceMapping::push_back(const unsigned long) –> void

resize(*args, **kwargs)

Overloaded function.

1. resize(self: pyrosetta.rosetta.core.id.SequenceMapping, s1: int, s2: int) -> None

2. resize(self: pyrosetta.rosetta.core.id.SequenceMapping, s1: int, s2: int, clear_values: bool) -> None

resize

new size of the target sequence

new size of the aligned sequence

optional parameter, defaults to true. By default, reset mapping to empty. Cases where passing clear_values as false is desired should be rare.

C++: core::id::SequenceMapping::resize(const unsigned long, const unsigned long, bool) –> void

reverse(self: pyrosetta.rosetta.core.id.SequenceMapping) → None

go from an A->B mapping to a B->A mapping

C++: core::id::SequenceMapping::reverse() –> void

same_type_as_me(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping, other: pyrosetta.rosetta.core.id.SequenceMapping) → bool

C++: core::sequence::DerivedSequenceMapping::same_type_as_me(const class core::id::SequenceMapping &) const –> bool

seq1(*args, **kwargs)

Overloaded function.

1. seq1(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping) -> str

C++: core::sequence::DerivedSequenceMapping::seq1() –> std::string &

2. seq1(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping, s: str) -> None

C++: core::sequence::DerivedSequenceMapping::seq1(const std::string &) –> void

seq2(*args, **kwargs)

Overloaded function.

1. seq2(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping) -> str

C++: core::sequence::DerivedSequenceMapping::seq2() –> std::string &

2. seq2(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping, s: str) -> None

C++: core::sequence::DerivedSequenceMapping::seq2(const std::string &) –> void

set_offset(self: pyrosetta.rosetta.core.id.SequenceMapping, setting: int) → None

C++: core::id::SequenceMapping::set_offset(int) –> void

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.core.id.SequenceMapping) -> None

C++: core::id::SequenceMapping::show() const –> void

2. show(self: pyrosetta.rosetta.core.id.SequenceMapping, output: pyrosetta.rosetta.std.ostream) -> None

C++: core::id::SequenceMapping::show(std::ostream &) const –> void

size1(self: pyrosetta.rosetta.core.id.SequenceMapping) → int

size of target sequence

C++: core::id::SequenceMapping::size1() const –> unsigned long

size2(*args, **kwargs)

Overloaded function.

1. size2(self: pyrosetta.rosetta.core.id.SequenceMapping) -> int

size of aligned sequence ???

C++: core::id::SequenceMapping::size2() const –> unsigned long

2. size2(self: pyrosetta.rosetta.core.id.SequenceMapping, s2: int) -> None

C++: core::id::SequenceMapping::size2(const unsigned long) –> void

start_seq2(*args, **kwargs)

Overloaded function.

1. start_seq2(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping) -> int

C++: core::sequence::DerivedSequenceMapping::start_seq2() const –> const unsigned long &

2. start_seq2(self: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping, s: int) -> None

C++: core::sequence::DerivedSequenceMapping::start_seq2(unsigned long) –> void

to_string(self: pyrosetta.rosetta.core.id.SequenceMapping) → str

C++: core::id::SequenceMapping::to_string() const –> std::string

upstream_combine(self: pyrosetta.rosetta.core.id.SequenceMapping, smap_to_add: pyrosetta.rosetta.core.id.SequenceMapping) → None

Apply a C->A mapping to the current A->B mapping to get a C->B mapping

i.e. smap[j] becomes smap[ smap_to_add[ j ] ]

C++: core::id::SequenceMapping::upstream_combine(const class core::id::SequenceMapping &) –> void

class pyrosetta.rosetta.core.sequence.L1ScoringScheme

Bases: ScoringScheme

assign(self: pyrosetta.rosetta.core.sequence.L1ScoringScheme, : pyrosetta.rosetta.core.sequence.L1ScoringScheme) → pyrosetta.rosetta.core.sequence.L1ScoringScheme

C++: core::sequence::L1ScoringScheme::operator=(const class core::sequence::L1ScoringScheme &) –> class core::sequence::L1ScoringScheme &

clone(self: pyrosetta.rosetta.core.sequence.L1ScoringScheme) → pyrosetta.rosetta.core.sequence.ScoringScheme

C++: core::sequence::L1ScoringScheme::clone() const –> class std::shared_ptr<class core::sequence::ScoringScheme>

gap_extend(*args, **kwargs)

Overloaded function.

1. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend() const –> double

2. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_extend: float) -> None

Sets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend(const double) –> void

gap_open(*args, **kwargs)

Overloaded function.

1. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open() const –> double

2. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_open: float) -> None

Sets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open(const double) –> void

is_good(self: pyrosetta.rosetta.core.sequence.ScoringScheme, num: float) → bool

C++: core::sequence::ScoringScheme::is_good(const double &) –> bool

read_data(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.io.izstream) → None

C++: core::sequence::ScoringScheme::read_data(class utility::io::izstream &) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.file.FileName) → None

Initialize from a file.

C++: core::sequence::ScoringScheme::read_from_file(const class utility::file::FileName &) –> void

score(self: pyrosetta.rosetta.core.sequence.L1ScoringScheme, seq1: pyrosetta.rosetta.core.sequence.Sequence, seq2: pyrosetta.rosetta.core.sequence.Sequence, pos1: int, pos2: int) → float

C++: core::sequence::L1ScoringScheme::score(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, unsigned long, unsigned long) –> double

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> str

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type() const –> std::string

2. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme, new_type: str) -> None

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type(std::string) –> void

unimplemented_method_error(self: pyrosetta.rosetta.core.sequence.ScoringScheme, method_name: str) → None

Utility method for producing useful error messages and exiting

from program. Declared const which is funny, because exiting the program certainly changes the state of this object! This might be replaced with exception handling if we ever start using those.

C++: core::sequence::ScoringScheme::unimplemented_method_error(const std::string &) const –> void

class pyrosetta.rosetta.core.sequence.Line

Bases: pybind11_object

struct

assign(self: pyrosetta.rosetta.core.sequence.Line, rval: pyrosetta.rosetta.core.sequence.Line) → pyrosetta.rosetta.core.sequence.Line

copy assignment

C++: core::sequence::Line::operator=(const struct core::sequence::Line &) –> struct core::sequence::Line &

property intercept

property region

property slope

class pyrosetta.rosetta.core.sequence.MCAligner

Bases: Aligner

align(self: pyrosetta.rosetta.core.sequence.MCAligner, seq_y: pyrosetta.rosetta.core.sequence.Sequence, seq_x: pyrosetta.rosetta.core.sequence.Sequence, ss: pyrosetta.rosetta.core.sequence.ScoringScheme) → core::sequence::SequenceAlignment

Align these two Sequences using the given ScoringScheme. Rather

than finding an optimal alignment, MCAligner uses a stochastic algorithm to generate an alignment at a given kT.

The Needleman-Wunsch algorithm uses dynamic programming to generate an optimal alignment between two scoring sequences under a given scoring scheme. Rather than making the best decision at each element of the dynamic programming matrix, MCAligner makes a stochastic decision between introducing a gap in seq_y, introducing a gap in seq_x, or aligning two characters between the two sequences. The decision is made by transforming the scores for each of the three possible decisions into probabilities using Boltzmann weighting of the scores for each possibility at a given kT. The kT is stored as a member variable of the MCAligner class, and accessor methods are provided above.

C++: core::sequence::MCAligner::align(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::ScoringScheme>) –> class core::sequence::SequenceAlignment

assign(self: pyrosetta.rosetta.core.sequence.MCAligner, : pyrosetta.rosetta.core.sequence.MCAligner) → pyrosetta.rosetta.core.sequence.MCAligner

C++: core::sequence::MCAligner::operator=(const class core::sequence::MCAligner &) –> class core::sequence::MCAligner &

kT(*args, **kwargs)

Overloaded function.

1. kT(self: pyrosetta.rosetta.core.sequence.MCAligner, new_kT: float) -> None

Sets the kT used in the align method. A optimal value of kT means

acceptance of less optimal decisions along the dynamic programming matrix.

C++: core::sequence::MCAligner::kT(double) –> void

2. kT(self: pyrosetta.rosetta.core.sequence.MCAligner) -> float

Returns the kT used in the align method.

C++: core::sequence::MCAligner::kT() const –> double

traceback(self: pyrosetta.rosetta.core.sequence.Aligner, seq_x: core::sequence::Sequence, seq_y: core::sequence::Sequence, matrix: pyrosetta.rosetta.core.sequence.DP_Matrix, start: pyrosetta.rosetta.core.sequence.Cell) → core::sequence::SequenceAlignment

C++: core::sequence::Aligner::traceback(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, class core::sequence::DP_Matrix, class std::shared_ptr<class core::sequence::Cell>) –> class core::sequence::SequenceAlignment

validate_input(self: pyrosetta.rosetta.core.sequence.Aligner, seq_y: core::sequence::Sequence, seq_x: core::sequence::Sequence, ss: core::sequence::ScoringScheme) → None

C++: core::sequence::Aligner::validate_input(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::ScoringScheme>) –> void

class pyrosetta.rosetta.core.sequence.MatrixScoringScheme

Bases: ScoringScheme

assign(self: pyrosetta.rosetta.core.sequence.MatrixScoringScheme, : pyrosetta.rosetta.core.sequence.MatrixScoringScheme) → pyrosetta.rosetta.core.sequence.MatrixScoringScheme

C++: core::sequence::MatrixScoringScheme::operator=(const class core::sequence::MatrixScoringScheme &) –> class core::sequence::MatrixScoringScheme &

clone(self: pyrosetta.rosetta.core.sequence.MatrixScoringScheme) → pyrosetta.rosetta.core.sequence.ScoringScheme

returns owning pointer to a new object with a deep copy of

this object’s values.

C++: core::sequence::MatrixScoringScheme::clone() const –> class std::shared_ptr<class core::sequence::ScoringScheme>

gap_extend(*args, **kwargs)

Overloaded function.

1. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend() const –> double

2. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_extend: float) -> None

Sets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend(const double) –> void

gap_open(*args, **kwargs)

Overloaded function.

1. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open() const –> double

2. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_open: float) -> None

Sets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open(const double) –> void

is_good(self: pyrosetta.rosetta.core.sequence.ScoringScheme, num: float) → bool

C++: core::sequence::ScoringScheme::is_good(const double &) –> bool

read_data(self: pyrosetta.rosetta.core.sequence.MatrixScoringScheme, input: pyrosetta.rosetta.utility.io.izstream) → None

C++: core::sequence::MatrixScoringScheme::read_data(class utility::io::izstream &) –> void

read_from_database(*args, **kwargs)

Overloaded function.

1. read_from_database(self: pyrosetta.rosetta.core.sequence.MatrixScoringScheme) -> None

2. read_from_database(self: pyrosetta.rosetta.core.sequence.MatrixScoringScheme, name: str) -> None

Read an alignment matrix from the given database filename using the

NCBI BLOSUM format for matrices.

C++: core::sequence::MatrixScoringScheme::read_from_database(std::string) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.MatrixScoringScheme, fn: pyrosetta.rosetta.utility.file.FileName) → None

Read an alignment matrix from the given filename using the

NCBI BLOSUM format for matrices.

C++: core::sequence::MatrixScoringScheme::read_from_file(const class utility::file::FileName &) –> void

score(self: pyrosetta.rosetta.core.sequence.MatrixScoringScheme, seq1: pyrosetta.rosetta.core.sequence.Sequence, seq2: pyrosetta.rosetta.core.sequence.Sequence, pos1: int, pos2: int) → float

C++: core::sequence::MatrixScoringScheme::score(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, unsigned long, unsigned long) –> double

scoring_matrix(self: pyrosetta.rosetta.core.sequence.MatrixScoringScheme) → pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t

C++: core::sequence::MatrixScoringScheme::scoring_matrix() const –> class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > >

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> str

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type() const –> std::string

2. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme, new_type: str) -> None

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type(std::string) –> void

unimplemented_method_error(self: pyrosetta.rosetta.core.sequence.ScoringScheme, method_name: str) → None

Utility method for producing useful error messages and exiting

from program. Declared const which is funny, because exiting the program certainly changes the state of this object! This might be replaced with exception handling if we ever start using those.

C++: core::sequence::ScoringScheme::unimplemented_method_error(const std::string &) const –> void

values_for_aa(*args, **kwargs)

Overloaded function.

1. values_for_aa(self: pyrosetta.rosetta.core.sequence.MatrixScoringScheme, aa: str) -> pyrosetta.rosetta.utility.vector1_double

Get the values for amino acid aa, in Rosetta aa order.

C++: core::sequence::MatrixScoringScheme::values_for_aa(char) –> class utility::vector1<double, class std::allocator<double> >

2. values_for_aa(self: pyrosetta.rosetta.core.sequence.MatrixScoringScheme, aa: pyrosetta.rosetta.core.chemical.AA) -> pyrosetta.rosetta.utility.vector1_double

Get the values for amino acid aa, in Rosetta aa order.

C++: core::sequence::MatrixScoringScheme::values_for_aa(enum core::chemical::AA) –> class utility::vector1<double, class std::allocator<double> >

class pyrosetta.rosetta.core.sequence.NWAligner

Bases: Aligner

align(self: pyrosetta.rosetta.core.sequence.NWAligner, seq_y: pyrosetta.rosetta.core.sequence.Sequence, seq_x: pyrosetta.rosetta.core.sequence.Sequence, ss: pyrosetta.rosetta.core.sequence.ScoringScheme) → core::sequence::SequenceAlignment

C++: core::sequence::NWAligner::align(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::ScoringScheme>) –> class core::sequence::SequenceAlignment

assign(self: pyrosetta.rosetta.core.sequence.NWAligner, : pyrosetta.rosetta.core.sequence.NWAligner) → pyrosetta.rosetta.core.sequence.NWAligner

C++: core::sequence::NWAligner::operator=(const class core::sequence::NWAligner &) –> class core::sequence::NWAligner &

static init_matrix(y_len: int, x_len: int, ss: pyrosetta.rosetta.core.sequence.ScoringScheme, scores: pyrosetta.rosetta.core.sequence.DP_Matrix) → None

C++: core::sequence::NWAligner::init_matrix(unsigned long, unsigned long, class std::shared_ptr<class core::sequence::ScoringScheme>, class core::sequence::DP_Matrix &) –> void

traceback(self: pyrosetta.rosetta.core.sequence.Aligner, seq_x: core::sequence::Sequence, seq_y: core::sequence::Sequence, matrix: pyrosetta.rosetta.core.sequence.DP_Matrix, start: pyrosetta.rosetta.core.sequence.Cell) → core::sequence::SequenceAlignment

C++: core::sequence::Aligner::traceback(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, class core::sequence::DP_Matrix, class std::shared_ptr<class core::sequence::Cell>) –> class core::sequence::SequenceAlignment

validate_input(self: pyrosetta.rosetta.core.sequence.Aligner, seq_y: core::sequence::Sequence, seq_x: core::sequence::Sequence, ss: core::sequence::ScoringScheme) → None

C++: core::sequence::Aligner::validate_input(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::ScoringScheme>) –> void

class pyrosetta.rosetta.core.sequence.PairScoringScheme

Bases: ScoringScheme

add_scored_pair(self: pyrosetta.rosetta.core.sequence.PairScoringScheme, res1: int, res2: int, score: float) → None

C++: core::sequence::PairScoringScheme::add_scored_pair(const unsigned long, const unsigned long, const double) –> void

assign(self: pyrosetta.rosetta.core.sequence.PairScoringScheme, : pyrosetta.rosetta.core.sequence.PairScoringScheme) → pyrosetta.rosetta.core.sequence.PairScoringScheme

C++: core::sequence::PairScoringScheme::operator=(const class core::sequence::PairScoringScheme &) –> class core::sequence::PairScoringScheme &

clone(self: pyrosetta.rosetta.core.sequence.PairScoringScheme) → pyrosetta.rosetta.core.sequence.ScoringScheme

C++: core::sequence::PairScoringScheme::clone() const –> class std::shared_ptr<class core::sequence::ScoringScheme>

gap_extend(*args, **kwargs)

Overloaded function.

1. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend() const –> double

2. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_extend: float) -> None

Sets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend(const double) –> void

gap_open(*args, **kwargs)

Overloaded function.

1. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open() const –> double

2. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_open: float) -> None

Sets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open(const double) –> void

is_good(self: pyrosetta.rosetta.core.sequence.ScoringScheme, num: float) → bool

C++: core::sequence::ScoringScheme::is_good(const double &) –> bool

pairs(self: pyrosetta.rosetta.core.sequence.PairScoringScheme) → pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t

C++: core::sequence::PairScoringScheme::pairs() const –> class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > >

read_data(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.io.izstream) → None

C++: core::sequence::ScoringScheme::read_data(class utility::io::izstream &) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.PairScoringScheme, fn: pyrosetta.rosetta.utility.file.FileName) → None

C++: core::sequence::PairScoringScheme::read_from_file(const class utility::file::FileName &) –> void

score(self: pyrosetta.rosetta.core.sequence.PairScoringScheme, seq1: pyrosetta.rosetta.core.sequence.Sequence, seq2: pyrosetta.rosetta.core.sequence.Sequence, pos1: int, pos2: int) → float

C++: core::sequence::PairScoringScheme::score(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, unsigned long, unsigned long) –> double

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> str

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type() const –> std::string

2. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme, new_type: str) -> None

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type(std::string) –> void

unimplemented_method_error(self: pyrosetta.rosetta.core.sequence.ScoringScheme, method_name: str) → None

Utility method for producing useful error messages and exiting

from program. Declared const which is funny, because exiting the program certainly changes the state of this object! This might be replaced with exception handling if we ever start using those.

C++: core::sequence::ScoringScheme::unimplemented_method_error(const std::string &) const –> void

class pyrosetta.rosetta.core.sequence.ProfSimScoringScheme

Bases: ScoringScheme

assign(self: pyrosetta.rosetta.core.sequence.ProfSimScoringScheme, : pyrosetta.rosetta.core.sequence.ProfSimScoringScheme) → pyrosetta.rosetta.core.sequence.ProfSimScoringScheme

C++: core::sequence::ProfSimScoringScheme::operator=(const class core::sequence::ProfSimScoringScheme &) –> class core::sequence::ProfSimScoringScheme &

clone(self: pyrosetta.rosetta.core.sequence.ProfSimScoringScheme) → pyrosetta.rosetta.core.sequence.ScoringScheme

returns owning pointer to a new object with a deep copy of this

object’s values.

C++: core::sequence::ProfSimScoringScheme::clone() const –> class std::shared_ptr<class core::sequence::ScoringScheme>

gap_extend(*args, **kwargs)

Overloaded function.

1. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend() const –> double

2. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_extend: float) -> None

Sets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend(const double) –> void

gap_open(*args, **kwargs)

Overloaded function.

1. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open() const –> double

2. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_open: float) -> None

Sets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open(const double) –> void

initialize_parameters(self: pyrosetta.rosetta.core.sequence.ProfSimScoringScheme) → None

Initialize log-probabilities of occurence for each amino acid.

C++: core::sequence::ProfSimScoringScheme::initialize_parameters() –> void

is_good(self: pyrosetta.rosetta.core.sequence.ScoringScheme, num: float) → bool

C++: core::sequence::ScoringScheme::is_good(const double &) –> bool

read_data(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.io.izstream) → None

C++: core::sequence::ScoringScheme::read_data(class utility::io::izstream &) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.file.FileName) → None

Initialize from a file.

C++: core::sequence::ScoringScheme::read_from_file(const class utility::file::FileName &) –> void

score(self: pyrosetta.rosetta.core.sequence.ProfSimScoringScheme, seq1: pyrosetta.rosetta.core.sequence.Sequence, seq2: pyrosetta.rosetta.core.sequence.Sequence, pos1: int, pos2: int) → float

ProfSim profile-profile similarity metric based on information theory.

Published by Yona and Levitt in JMB, 2002 in a paper titled “Within the Twilight Zone: A Sensitive Profile-Profile Comparison Tool Based on Information Theory.”

The basic idea for this score is that it incorporates both divergence of probability distributions at each position and the significance of that divergence in order to construct a position-specific profile-profile score. The divergence score is the J-S divergence between the two probability distributions at probability position, and the significance score is the J-S divergence between: 1. the average of the two probability distributions at this position 2. a prior probability distribution over all allowed characters at this position. J-S divergence between two distributions is defined as: D( p1, p2 ) = 0.5 * sum( p1[i] * log( p1[i] / p2[i] ) ) +

0.5 * sum( p2[i] * log( p2[i] / p1[i] ) )

C++: core::sequence::ProfSimScoringScheme::score(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, unsigned long, unsigned long) –> double

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> str

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type() const –> std::string

2. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme, new_type: str) -> None

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type(std::string) –> void

unimplemented_method_error(self: pyrosetta.rosetta.core.sequence.ScoringScheme, method_name: str) → None

Utility method for producing useful error messages and exiting

from program. Declared const which is funny, because exiting the program certainly changes the state of this object! This might be replaced with exception handling if we ever start using those.

C++: core::sequence::ScoringScheme::unimplemented_method_error(const std::string &) const –> void

class pyrosetta.rosetta.core.sequence.SSManager

Bases: pybind11_object

manager for abego

assign(self: pyrosetta.rosetta.core.sequence.SSManager, : pyrosetta.rosetta.core.sequence.SSManager) → pyrosetta.rosetta.core.sequence.SSManager

C++: core::sequence::SSManager::operator=(const class core::sequence::SSManager &) –> class core::sequence::SSManager &

index2symbol(self: pyrosetta.rosetta.core.sequence.SSManager, idx: int) → str

transform abego index to symbol

C++: core::sequence::SSManager::index2symbol(const unsigned long &) –> char

index2symbolString(self: pyrosetta.rosetta.core.sequence.SSManager, base5index: int, length: int) → str

transform abego string to abego base5 index

C++: core::sequence::SSManager::index2symbolString(unsigned long, unsigned long) –> std::string

symbol2index(self: pyrosetta.rosetta.core.sequence.SSManager, symbol: str) → int

transform abego symbol to index

C++: core::sequence::SSManager::symbol2index(const char &) –> unsigned long

symbolString2index(self: pyrosetta.rosetta.core.sequence.SSManager, symbolString: str) → int

transform abego symbol string to base5 index

C++: core::sequence::SSManager::symbolString2index(std::string) –> unsigned long

class pyrosetta.rosetta.core.sequence.SWAligner

Bases: Aligner

align(self: pyrosetta.rosetta.core.sequence.SWAligner, seq_y: pyrosetta.rosetta.core.sequence.Sequence, seq_x: pyrosetta.rosetta.core.sequence.Sequence, ss: pyrosetta.rosetta.core.sequence.ScoringScheme) → core::sequence::SequenceAlignment

C++: core::sequence::SWAligner::align(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::ScoringScheme>) –> class core::sequence::SequenceAlignment

assign(self: pyrosetta.rosetta.core.sequence.SWAligner, : pyrosetta.rosetta.core.sequence.SWAligner) → pyrosetta.rosetta.core.sequence.SWAligner

C++: core::sequence::SWAligner::operator=(const class core::sequence::SWAligner &) –> class core::sequence::SWAligner &

traceback(self: pyrosetta.rosetta.core.sequence.Aligner, seq_x: core::sequence::Sequence, seq_y: core::sequence::Sequence, matrix: pyrosetta.rosetta.core.sequence.DP_Matrix, start: pyrosetta.rosetta.core.sequence.Cell) → core::sequence::SequenceAlignment

C++: core::sequence::Aligner::traceback(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, class core::sequence::DP_Matrix, class std::shared_ptr<class core::sequence::Cell>) –> class core::sequence::SequenceAlignment

validate_input(self: pyrosetta.rosetta.core.sequence.Aligner, seq_y: core::sequence::Sequence, seq_x: core::sequence::Sequence, ss: core::sequence::ScoringScheme) → None

C++: core::sequence::Aligner::validate_input(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::ScoringScheme>) –> void

class pyrosetta.rosetta.core.sequence.ScoringScheme

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.core.sequence.ScoringScheme) → pyrosetta.rosetta.core.sequence.ScoringScheme

C++: core::sequence::ScoringScheme::operator=(const class core::sequence::ScoringScheme &) –> class core::sequence::ScoringScheme &

clone(self: pyrosetta.rosetta.core.sequence.ScoringScheme) → pyrosetta.rosetta.core.sequence.ScoringScheme

clone method.

C++: core::sequence::ScoringScheme::clone() const –> class std::shared_ptr<class core::sequence::ScoringScheme>

gap_extend(*args, **kwargs)

Overloaded function.

1. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend() const –> double

2. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_extend: float) -> None

Sets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend(const double) –> void

gap_open(*args, **kwargs)

Overloaded function.

1. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open() const –> double

2. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_open: float) -> None

Sets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open(const double) –> void

is_good(self: pyrosetta.rosetta.core.sequence.ScoringScheme, num: float) → bool

C++: core::sequence::ScoringScheme::is_good(const double &) –> bool

read_data(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.io.izstream) → None

C++: core::sequence::ScoringScheme::read_data(class utility::io::izstream &) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.file.FileName) → None

Initialize from a file.

C++: core::sequence::ScoringScheme::read_from_file(const class utility::file::FileName &) –> void

score(self: pyrosetta.rosetta.core.sequence.ScoringScheme, seq1: core::sequence::Sequence, seq2: core::sequence::Sequence, pos1: int, pos2: int) → float

C++: core::sequence::ScoringScheme::score(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, unsigned long, unsigned long) –> double

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> str

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type() const –> std::string

2. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme, new_type: str) -> None

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type(std::string) –> void

unimplemented_method_error(self: pyrosetta.rosetta.core.sequence.ScoringScheme, method_name: str) → None

Utility method for producing useful error messages and exiting

from program. Declared const which is funny, because exiting the program certainly changes the state of this object! This might be replaced with exception handling if we ever start using those.

C++: core::sequence::ScoringScheme::unimplemented_method_error(const std::string &) const –> void

class pyrosetta.rosetta.core.sequence.ScoringSchemeFactory

Bases: pybind11_object

add_type(self: pyrosetta.rosetta.core.sequence.ScoringSchemeFactory, new_scheme: pyrosetta.rosetta.core.sequence.ScoringScheme) → None

adds a ScoringSchemeOP

C++: core::sequence::ScoringSchemeFactory::add_type(class std::shared_ptr<class core::sequence::ScoringScheme>) –> void

get_scoring_scheme(self: pyrosetta.rosetta.core.sequence.ScoringSchemeFactory, type: str) → pyrosetta.rosetta.core.sequence.ScoringScheme

C++: core::sequence::ScoringSchemeFactory::get_scoring_scheme(const std::string &) const –> class std::shared_ptr<class core::sequence::ScoringScheme>

property scheme_types_

class pyrosetta.rosetta.core.sequence.Sequence

Bases: pybind11_object

append_char(self: pyrosetta.rosetta.core.sequence.Sequence, new_char: str) → None

Append a character

C++: core::sequence::Sequence::append_char(char) –> void

append_gap(self: pyrosetta.rosetta.core.sequence.Sequence) → None

Append a gap

C++: core::sequence::Sequence::append_gap() –> void

assign(self: pyrosetta.rosetta.core.sequence.Sequence, rhs: pyrosetta.rosetta.core.sequence.Sequence) → pyrosetta.rosetta.core.sequence.Sequence

assignment operator.

C++: core::sequence::Sequence::operator=(const class core::sequence::Sequence &) –> class core::sequence::Sequence &

at(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → str

C++: core::sequence::Sequence::at(unsigned long) const –> char

clone(self: pyrosetta.rosetta.core.sequence.Sequence) → pyrosetta.rosetta.core.sequence.Sequence

Returns an owning pointer to a copy of this sequence.

C++: core::sequence::Sequence::clone() const –> class std::shared_ptr<class core::sequence::Sequence>

delete_position(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → None

Deletes the given position from the Sequence and shifts

everything else back by one.

C++: core::sequence::Sequence::delete_position(unsigned long) –> void

gap_char(*args, **kwargs)

Overloaded function.

1. gap_char(self: pyrosetta.rosetta.core.sequence.Sequence, gap_char: str) -> None

sets gap_char to the given value.

C++: core::sequence::Sequence::gap_char(char) –> void

2. gap_char(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the character used to represent a gap for this object.

C++: core::sequence::Sequence::gap_char() const –> char

id(*args, **kwargs)

Overloaded function.

1. id(self: pyrosetta.rosetta.core.sequence.Sequence, new_id: str) -> None

sets id to the given value.

C++: core::sequence::Sequence::id(std::string) –> void

2. id(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the id of this object.

C++: core::sequence::Sequence::id() const –> std::string

insert_char(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int, new_char: str) → None

Inserts a character at the given position.

C++: core::sequence::Sequence::insert_char(unsigned long, char) –> void

insert_gap(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → None

Inserts a gap at the given position, where insert_gap( 0 )

inserts the character at the beginning of the sequence, and insert_gap( length() ) inserts the character at the end of the sequence.

C++: core::sequence::Sequence::insert_gap(unsigned long) –> void

is_gap(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → bool

Returns true if this position in the sequence represents a gap,

returns false otherwise.

C++: core::sequence::Sequence::is_gap(unsigned long) const –> bool

length(self: pyrosetta.rosetta.core.sequence.Sequence) → int

Returns the number of characters in this object.

C++: core::sequence::Sequence::length() const –> unsigned long

read_data(self: pyrosetta.rosetta.core.sequence.Sequence, in: pyrosetta.rosetta.std.istream) → None

Initializes the information in this sequence from the given

std::istream. The istream should yield three pieces of information in the following order: - id - start - sequence

C++: core::sequence::Sequence::read_data(std::istream &) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.Sequence, : pyrosetta.rosetta.utility.file.FileName) → None

initializes this sequence object from a file.

C++: core::sequence::Sequence::read_from_file(const class utility::file::FileName &) –> void

replace_char(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int, new_char: str) → None

C++: core::sequence::Sequence::replace_char(unsigned long, char) –> void

resnum(self: pyrosetta.rosetta.core.sequence.Sequence, idx: int) → int

Returns the index of the given sequence position, which is the

position in the sequence minus any gaps that occur earlier in the sequence. For example, if the sequence is —AT, resnum(5) will return 2. Returns 0 for unaligned positions.

C++: core::sequence::Sequence::resnum(unsigned long) const –> unsigned long

sequence(*args, **kwargs)

Overloaded function.

1. sequence(self: pyrosetta.rosetta.core.sequence.Sequence, sequence: str) -> None

sets sequence to the given value.

C++: core::sequence::Sequence::sequence(std::string) –> void

2. sequence(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the full sequence, which may include gaps.

C++: core::sequence::Sequence::sequence() const –> std::string

spacer_positions(*args, **kwargs)

Overloaded function.

1. spacer_positions(self: pyrosetta.rosetta.core.sequence.Sequence, spacer_positions: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

sets spacer_positions to the given value.

C++: core::sequence::Sequence::spacer_positions(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

2. spacer_positions(self: pyrosetta.rosetta.core.sequence.Sequence) -> pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the spacer positions (chain breaks, e.g., from spaces or commas in original sequence text)

C++: core::sequence::Sequence::spacer_positions() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

start(*args, **kwargs)

Overloaded function.

1. start(self: pyrosetta.rosetta.core.sequence.Sequence, new_start: int) -> None

sets starting index to the given value.

C++: core::sequence::Sequence::start(unsigned long) –> void

2. start(self: pyrosetta.rosetta.core.sequence.Sequence) -> int

Returns the start of this object.

C++: core::sequence::Sequence::start() const –> unsigned long

to_string(self: pyrosetta.rosetta.core.sequence.Sequence) → str

C++: core::sequence::Sequence::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.sequence.Sequence) → str

C++: core::sequence::Sequence::type() const –> std::string

ungapped_length(self: pyrosetta.rosetta.core.sequence.Sequence) → int

Returns the number of characters in this object, ignoring gaps.

C++: core::sequence::Sequence::ungapped_length() const –> unsigned long

ungapped_sequence(self: pyrosetta.rosetta.core.sequence.Sequence) → str

Returns the string representing this sequence without gaps.

C++: core::sequence::Sequence::ungapped_sequence() const –> std::string

class pyrosetta.rosetta.core.sequence.SequenceAlignment

Bases: pybind11_object

add_sequence(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, myseq: pyrosetta.rosetta.core.sequence.Sequence) → None

C++: core::sequence::SequenceAlignment::add_sequence(class std::shared_ptr<class core::sequence::Sequence>) –> void

alignment_id(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) → str

this gives the id of the second sequence

— in a typical alignment it is 1) query, 2) template

C++: core::sequence::SequenceAlignment::alignment_id() const –> std::string

assign(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, src: pyrosetta.rosetta.core.sequence.SequenceAlignment) → pyrosetta.rosetta.core.sequence.SequenceAlignment

assignment operator

C++: core::sequence::SequenceAlignment::operator=(const class core::sequence::SequenceAlignment &) –> class core::sequence::SequenceAlignment &

calculate_per_position_scores(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, ss: pyrosetta.rosetta.core.sequence.ScoringScheme) → pyrosetta.rosetta.utility.vector1_double

calculates pairwise scores similar to

calculate_score_sum_of_pairs.

C++: core::sequence::SequenceAlignment::calculate_per_position_scores(class std::shared_ptr<class core::sequence::ScoringScheme>) const –> class utility::vector1<double, class std::allocator<double> >

calculate_score_sum_of_pairs(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, ss: pyrosetta.rosetta.core.sequence.ScoringScheme) → float

calculates the score of this alignment under

the given ScoringScheme by summing up all of pairwise alignment scores between all pairs of sequence.

C++: core::sequence::SequenceAlignment::calculate_score_sum_of_pairs(class std::shared_ptr<class core::sequence::ScoringScheme>) const –> double

clear(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) → None

C++: core::sequence::SequenceAlignment::clear() –> void

clone(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) → pyrosetta.rosetta.core.sequence.SequenceAlignment

C++: core::sequence::SequenceAlignment::clone() const –> class std::shared_ptr<class core::sequence::SequenceAlignment>

comment(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, comment: str) → None

getter/setters for comments

C++: core::sequence::SequenceAlignment::comment(const std::string &) –> void

comments(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) → pyrosetta.rosetta.utility.vector1_std_string

C++: core::sequence::SequenceAlignment::comments() const –> class utility::vector1<std::string, class std::allocator<std::string > >

data_integrity_check(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) → None

C++: core::sequence::SequenceAlignment::data_integrity_check() const –> void

gapped_positions(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) → int

Returns the number of positions in the

SequenceAlignment with at least one gap.

C++: core::sequence::SequenceAlignment::gapped_positions() const –> unsigned long

identities(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) → int

Returns the number of positions at which all

C++: core::sequence::SequenceAlignment::identities() const –> unsigned long

is_gapped(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, col_idx: int) → bool

Returns true if the given alignment column index is gapped,

false otherwise.

C++: core::sequence::SequenceAlignment::is_gapped(const unsigned long) const –> bool

length(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) → int

Returns the length of all sequences in this SequenceAlignment.

C++: core::sequence::SequenceAlignment::length() const –> unsigned long

max_gap_percentage(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) → float

Returns the number of gaps contained by

the sequence in the alignment with the most gaps.

C++: core::sequence::SequenceAlignment::max_gap_percentage() const –> double

printGrishinFormat(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, out: pyrosetta.rosetta.std.ostream) → None

C++: core::sequence::SequenceAlignment::printGrishinFormat(std::ostream &) const –> void

read_data(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, in: pyrosetta.rosetta.std.istream) → None

C++: core::sequence::SequenceAlignment::read_data(std::istream &) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, filename: str) → None

initialize this SequenceAlignment object from the

given file.

C++: core::sequence::SequenceAlignment::read_from_file(const std::string &) –> void

remove_gapped_positions(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) → None

Removes positions that are gapped in all

columns of the alignment.

C++: core::sequence::SequenceAlignment::remove_gapped_positions() –> void

score(*args, **kwargs)

Overloaded function.

1. score(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, sc: float) -> None

Accessors for the score of this SequenceAlignment.

C++: core::sequence::SequenceAlignment::score(const double &) –> void

2. score(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) -> float

C++: core::sequence::SequenceAlignment::score() const –> double

3. score(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, name: str) -> float

C++: core::sequence::SequenceAlignment::score(const std::string &) const –> double

4. score(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, name: str, value: float) -> None

C++: core::sequence::SequenceAlignment::score(const std::string &, const double) –> void

scores(*args, **kwargs)

Overloaded function.

1. scores(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) -> pyrosetta.rosetta.std.map_std_string_double

C++: core::sequence::SequenceAlignment::scores() const –> class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >

2. scores(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, new_scores: pyrosetta.rosetta.std.map_std_string_double) -> None

C++: core::sequence::SequenceAlignment::scores(class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > >) –> void

sequence(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, idx: int) → pyrosetta.rosetta.core.sequence.Sequence

C++: core::sequence::SequenceAlignment::sequence(unsigned long) const –> class std::shared_ptr<class core::sequence::Sequence>

sequence_indices(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, column: int) → pyrosetta.rosetta.utility.vector1_unsigned_long

Returns a vector1 of the sequence indices in

the given column of the SequenceAlignment that are calculated using the Sequence resnum() method.

C++: core::sequence::SequenceAlignment::sequence_indices(const unsigned long) const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

sequence_mapping(self: pyrosetta.rosetta.core.sequence.SequenceAlignment, idx1: int, idx2: int) → pyrosetta.rosetta.core.id.SequenceMapping

returns a SequenceMapping of the sequence at index

idx1 mapped to the sequence at idx2.

C++: core::sequence::SequenceAlignment::sequence_mapping(const unsigned long, const unsigned long) const –> class core::id::SequenceMapping

sequences_are_in_frame(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) → bool

Returns true if all of the sequences are

“in-frame,” which means that residue x in the first sequence maps to residue x in all other sequences. This method intentionally ignores any sequence at the position where that sequence has a gap.

C++: core::sequence::SequenceAlignment::sequences_are_in_frame() const –> bool

size(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) → int

Returns the number of sequences.

C++: core::sequence::SequenceAlignment::size() const –> unsigned long

to_string(self: pyrosetta.rosetta.core.sequence.SequenceAlignment) → str

C++: core::sequence::SequenceAlignment::to_string() const –> std::string

class pyrosetta.rosetta.core.sequence.SequenceAlignmentHasher

Bases: pybind11_object

Allows SequenceAlignment’s to be used as keys in unordered_{set|map}.

class pyrosetta.rosetta.core.sequence.SequenceCoupling

Bases: SequenceProfile

alphabet(*args, **kwargs)

Overloaded function.

1. alphabet(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> pyrosetta.rosetta.utility.vector1_std_string

Return the alphabet used by this sequence profile. This is an

N-dimensional vector1 where N is the width of the profile, and the ith entry of any row in the profile represents the probability of ith character at that row in the sequence.

C++: core::sequence::SequenceProfile::alphabet() const –> class utility::vector1<std::string, class std::allocator<std::string > >

2. alphabet(self: pyrosetta.rosetta.core.sequence.SequenceProfile, new_alphabet: pyrosetta.rosetta.utility.vector1_std_string) -> None

C++: core::sequence::SequenceProfile::alphabet(class utility::vector1<std::string, class std::allocator<std::string > >) –> void

append_char(self: pyrosetta.rosetta.core.sequence.Sequence, new_char: str) → None

Append a character

C++: core::sequence::Sequence::append_char(char) –> void

append_gap(self: pyrosetta.rosetta.core.sequence.Sequence) → None

Append a gap

C++: core::sequence::Sequence::append_gap() –> void

assign(self: pyrosetta.rosetta.core.sequence.SequenceCoupling, : pyrosetta.rosetta.core.sequence.SequenceCoupling) → pyrosetta.rosetta.core.sequence.SequenceCoupling

C++: core::sequence::SequenceCoupling::operator=(const class core::sequence::SequenceCoupling &) –> class core::sequence::SequenceCoupling &

at(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → str

C++: core::sequence::Sequence::at(unsigned long) const –> char

clone(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → pyrosetta.rosetta.core.sequence.Sequence

Returns an owning pointer to a new SequenceProfile object,

with data that is a deep copy of the information in this object.

C++: core::sequence::SequenceProfile::clone() const –> class std::shared_ptr<class core::sequence::Sequence>

convert_profile_to_probs(*args, **kwargs)

Overloaded function.

1. convert_profile_to_probs(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> None

2. convert_profile_to_probs(self: pyrosetta.rosetta.core.sequence.SequenceProfile, temp: float) -> None

Use boltzman scaling on a per-residue basis to convert the current profile values to probabilities ( range 0.0-1.0 )

C++: core::sequence::SequenceProfile::convert_profile_to_probs(double) –> void

delete_position(self: pyrosetta.rosetta.core.sequence.SequenceCoupling, pos: int) → None

Deletes the given position from the Sequence and shifts

everything else back by one.

C++: core::sequence::SequenceCoupling::delete_position(unsigned long) –> void

edgeList(*args, **kwargs)

Overloaded function.

1. edgeList(self: pyrosetta.rosetta.core.sequence.SequenceCoupling) -> pyrosetta.rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t

Print this SequenceCoupling object to the given std::ostream.

Commenting out to fix PyRosetta build friend std::ostream & operator<<( std::ostream & out, const SequenceCoupling & p );

C++: core::sequence::SequenceCoupling::edgeList() const –> class utility::vector1<class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class std::allocator<class utility::vector1<unsigned long, class std::allocator<unsigned long> > > >

2. edgeList(self: pyrosetta.rosetta.core.sequence.SequenceCoupling, eList: pyrosetta.rosetta.utility.vector1_utility_vector1_unsigned_long_std_allocator_unsigned_long_t) -> None

C++: core::sequence::SequenceCoupling::edgeList(const class utility::vector1<class utility::vector1<unsigned long, class std::allocator<unsigned long> >, class std::allocator<class utility::vector1<unsigned long, class std::allocator<unsigned long> > > > &) –> void

edgePotBetween(*args, **kwargs)

Overloaded function.

1. edgePotBetween(self: pyrosetta.rosetta.core.sequence.SequenceCoupling, vert1: int, vert2: int) -> pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t

C++: core::sequence::SequenceCoupling::edgePotBetween(unsigned long, unsigned long) const –> const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &

2. edgePotBetween(self: pyrosetta.rosetta.core.sequence.SequenceCoupling, edgeId: int) -> pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t

C++: core::sequence::SequenceCoupling::edgePotBetween(unsigned long) const –> const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &

edgePots(*args, **kwargs)

Overloaded function.

1. edgePots(self: pyrosetta.rosetta.core.sequence.SequenceCoupling) -> pyrosetta.rosetta.utility.vector1_utility_vector1_utility_vector1_double_std_allocator_double_std_allocator_utility_vector1_double_std_allocator_double_t

C++: core::sequence::SequenceCoupling::edgePots() const –> class utility::vector1<class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > >, class std::allocator<class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > > >

2. edgePots(self: pyrosetta.rosetta.core.sequence.SequenceCoupling, ePots: pyrosetta.rosetta.utility.vector1_utility_vector1_utility_vector1_double_std_allocator_double_std_allocator_utility_vector1_double_std_allocator_double_t) -> None

C++: core::sequence::SequenceCoupling::edgePots(const class utility::vector1<class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > >, class std::allocator<class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > > > &) –> void

findEdgeId(self: pyrosetta.rosetta.core.sequence.SequenceCoupling, vert1: int, vert2: int) → int

C++: core::sequence::SequenceCoupling::findEdgeId(unsigned long, unsigned long) const –> unsigned long

gap_char(*args, **kwargs)

Overloaded function.

1. gap_char(self: pyrosetta.rosetta.core.sequence.Sequence, gap_char: str) -> None

sets gap_char to the given value.

C++: core::sequence::Sequence::gap_char(char) –> void

2. gap_char(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the character used to represent a gap for this object.

C++: core::sequence::Sequence::gap_char() const –> char

generate_from_sequence(*args, **kwargs)

Overloaded function.

1. generate_from_sequence(self: pyrosetta.rosetta.core.sequence.SequenceProfile, seq: pyrosetta.rosetta.core.sequence.Sequence) -> None

2. generate_from_sequence(self: pyrosetta.rosetta.core.sequence.SequenceProfile, seq: pyrosetta.rosetta.core.sequence.Sequence, matrix: str) -> None

Generate the profile matrix from a sequence and a given substitution matrix

C++: core::sequence::SequenceProfile::generate_from_sequence(const class core::sequence::Sequence &, std::string) –> void

global_auto_rescale(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → None

Use linear rescaling (with a fixed zero) to fit the values within the range -1.0 to 1.0

C++: core::sequence::SequenceProfile::global_auto_rescale() –> void

id(*args, **kwargs)

Overloaded function.

1. id(self: pyrosetta.rosetta.core.sequence.Sequence, new_id: str) -> None

sets id to the given value.

C++: core::sequence::Sequence::id(std::string) –> void

2. id(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the id of this object.

C++: core::sequence::Sequence::id() const –> std::string

insert_char(self: pyrosetta.rosetta.core.sequence.SequenceCoupling, pos: int, new_char: str) → None

Read profile matrix from the given filename using the NNMAKE

.checkpoint format.

void read_from_checkpoint( FileName const & fn );

C++: core::sequence::SequenceCoupling::insert_char(unsigned long, char) –> void

insert_gap(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → None

Inserts a gap at the given position, where insert_gap( 0 )

inserts the character at the beginning of the sequence, and insert_gap( length() ) inserts the character at the end of the sequence.

C++: core::sequence::Sequence::insert_gap(unsigned long) –> void

is_gap(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → bool

Returns true if this position in the sequence represents a gap,

returns false otherwise.

C++: core::sequence::Sequence::is_gap(unsigned long) const –> bool

length(self: pyrosetta.rosetta.core.sequence.Sequence) → int

Returns the number of characters in this object.

C++: core::sequence::Sequence::length() const –> unsigned long

negative_better(*args, **kwargs)

Overloaded function.

1. negative_better(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> bool

Returns true if negative values are better identities.

The “default” use case is for storing log likelihood values where positive is better. If you’re using this class to store energy-like values, set negative_better to true.

C++: core::sequence::SequenceProfile::negative_better() const –> bool

2. negative_better(self: pyrosetta.rosetta.core.sequence.SequenceProfile, negbet: bool) -> None

Set whether negative identities are better.

C++: core::sequence::SequenceProfile::negative_better(bool) –> void

npos(self: pyrosetta.rosetta.core.sequence.SequenceCoupling) → int

C++: core::sequence::SequenceCoupling::npos() const –> unsigned long

occurrence_data(*args, **kwargs)

Overloaded function.

1. occurrence_data(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t

Returns the 2D vector1 of Real values of the probabilties of each aa.

C++: core::sequence::SequenceProfile::occurrence_data() const –> const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &

2. occurrence_data(self: pyrosetta.rosetta.core.sequence.SequenceProfile, new_occurrence_data: pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t) -> None

Sets the 2D vector1 of Real values of the probabilties of each aa.

C++: core::sequence::SequenceProfile::occurrence_data(const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &) –> void

probability_row(self: pyrosetta.rosetta.core.sequence.SequenceProfile, pos: int) → pyrosetta.rosetta.utility.vector1_double

C++: core::sequence::SequenceProfile::probability_row(unsigned long) const –> const class utility::vector1<double, class std::allocator<double> > &

probabilty_row(self: pyrosetta.rosetta.core.sequence.SequenceProfile, new_prob_row: pyrosetta.rosetta.utility.vector1_double, pos: int) → None

C++: core::sequence::SequenceProfile::probabilty_row(const class utility::vector1<double, class std::allocator<double> > &, unsigned long) –> void

prof_row(*args, **kwargs)

Overloaded function.

1. prof_row(self: pyrosetta.rosetta.core.sequence.SequenceProfile, pos: int) -> pyrosetta.rosetta.utility.vector1_double

Returns the vector1 of values at this position.

C++: core::sequence::SequenceProfile::prof_row(unsigned long) const –> const class utility::vector1<double, class std::allocator<double> > &

2. prof_row(self: pyrosetta.rosetta.core.sequence.SequenceProfile, new_prof_row: pyrosetta.rosetta.utility.vector1_double, pos: int) -> None

Sets the 1D vector1 of Real values representing this profile at pos X.

C++: core::sequence::SequenceProfile::prof_row(const class utility::vector1<double, class std::allocator<double> > &, unsigned long) –> void

profile(*args, **kwargs)

Overloaded function.

1. profile(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t

Returns the 2D vector1 of Real values representing this profile.

C++: core::sequence::SequenceProfile::profile() const –> const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &

2. profile(self: pyrosetta.rosetta.core.sequence.SequenceProfile, new_profile: pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t) -> None

Sets the 2D vector1 of Real values representing this profile.

C++: core::sequence::SequenceProfile::profile(const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &) –> void

read_data(self: pyrosetta.rosetta.core.sequence.Sequence, in: pyrosetta.rosetta.std.istream) → None

Initializes the information in this sequence from the given

std::istream. The istream should yield three pieces of information in the following order: - id - start - sequence

C++: core::sequence::Sequence::read_data(std::istream &) –> void

read_from_binary_chk(self: pyrosetta.rosetta.core.sequence.SequenceProfile, fn: pyrosetta.rosetta.utility.file.FileName) → None

Read profile matrix from the given filename in the legacy BLAST binary format

C++: core::sequence::SequenceProfile::read_from_binary_chk(const class utility::file::FileName &) –> void

read_from_checkpoint(*args, **kwargs)

Overloaded function.

1. read_from_checkpoint(self: pyrosetta.rosetta.core.sequence.SequenceProfile, fn: pyrosetta.rosetta.utility.file.FileName) -> None

2. read_from_checkpoint(self: pyrosetta.rosetta.core.sequence.SequenceProfile, fn: pyrosetta.rosetta.utility.file.FileName, negative_better: bool) -> None

Read profile matrix from the given filename using the NNMAKE

.checkpoint format. For compatability, negative_better defaults to true. Set manually if necessary.

C++: core::sequence::SequenceProfile::read_from_checkpoint(const class utility::file::FileName &, bool) –> void

read_from_file(*args, **kwargs)

Overloaded function.

1. read_from_file(self: pyrosetta.rosetta.core.sequence.SequenceCoupling, fn: pyrosetta.rosetta.utility.file.FileName) -> None

Read a SequenceCoupling model in GREMLIN format .

C++: core::sequence::SequenceCoupling::read_from_file(const class utility::file::FileName &) –> void

2. read_from_file(self: pyrosetta.rosetta.core.sequence.SequenceCoupling, fn: pyrosetta.rosetta.utility.file.FileName, temp: float) -> None

virtual SequenceOP clone() const {

SequenceOP new_seq_op( new SequenceProfile( *this ) ); return new_seq_op;

}

C++: core::sequence::SequenceCoupling::read_from_file(const class utility::file::FileName &, double) –> void

replace_char(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int, new_char: str) → None

C++: core::sequence::Sequence::replace_char(unsigned long, char) –> void

rescale(*args, **kwargs)

Overloaded function.

1. rescale(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> None

2. rescale(self: pyrosetta.rosetta.core.sequence.SequenceProfile, factor: float) -> None

Multiply all profile weights by factor

C++: core::sequence::SequenceProfile::rescale(double) –> void

resnum(self: pyrosetta.rosetta.core.sequence.Sequence, idx: int) → int

Returns the index of the given sequence position, which is the

position in the sequence minus any gaps that occur earlier in the sequence. For example, if the sequence is —AT, resnum(5) will return 2. Returns 0 for unaligned positions.

C++: core::sequence::Sequence::resnum(unsigned long) const –> unsigned long

sequence(*args, **kwargs)

Overloaded function.

1. sequence(self: pyrosetta.rosetta.core.sequence.Sequence, sequence: str) -> None

sets sequence to the given value.

C++: core::sequence::Sequence::sequence(std::string) –> void

2. sequence(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the full sequence, which may include gaps.

C++: core::sequence::Sequence::sequence() const –> std::string

size(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → int

C++: core::sequence::SequenceProfile::size() const –> unsigned long

spacer_positions(*args, **kwargs)

Overloaded function.

1. spacer_positions(self: pyrosetta.rosetta.core.sequence.Sequence, spacer_positions: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

sets spacer_positions to the given value.

C++: core::sequence::Sequence::spacer_positions(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

2. spacer_positions(self: pyrosetta.rosetta.core.sequence.Sequence) -> pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the spacer positions (chain breaks, e.g., from spaces or commas in original sequence text)

C++: core::sequence::Sequence::spacer_positions() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

start(*args, **kwargs)

Overloaded function.

1. start(self: pyrosetta.rosetta.core.sequence.Sequence, new_start: int) -> None

sets starting index to the given value.

C++: core::sequence::Sequence::start(unsigned long) –> void

2. start(self: pyrosetta.rosetta.core.sequence.Sequence) -> int

Returns the start of this object.

C++: core::sequence::Sequence::start() const –> unsigned long

temp(*args, **kwargs)

Overloaded function.

1. temp(self: pyrosetta.rosetta.core.sequence.SequenceCoupling) -> float

C++: core::sequence::SequenceCoupling::temp() const –> double

2. temp(self: pyrosetta.rosetta.core.sequence.SequenceCoupling, t: float) -> None

C++: core::sequence::SequenceCoupling::temp(const double) –> void

to_string(self: pyrosetta.rosetta.core.sequence.Sequence) → str

C++: core::sequence::Sequence::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.sequence.SequenceCoupling) → str

C++: core::sequence::SequenceCoupling::type() const –> std::string

ungapped_length(self: pyrosetta.rosetta.core.sequence.Sequence) → int

Returns the number of characters in this object, ignoring gaps.

C++: core::sequence::Sequence::ungapped_length() const –> unsigned long

ungapped_sequence(self: pyrosetta.rosetta.core.sequence.Sequence) → str

Returns the string representing this sequence without gaps.

C++: core::sequence::Sequence::ungapped_sequence() const –> std::string

width(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → int

Returns the number of distinct values at each position in this

profile.

C++: core::sequence::SequenceProfile::width() const –> unsigned long

class pyrosetta.rosetta.core.sequence.SequenceCouplingCreator

Bases: SequenceCreator

assign(self: pyrosetta.rosetta.core.sequence.SequenceCouplingCreator, : pyrosetta.rosetta.core.sequence.SequenceCouplingCreator) → pyrosetta.rosetta.core.sequence.SequenceCouplingCreator

C++: core::sequence::SequenceCouplingCreator::operator=(const class core::sequence::SequenceCouplingCreator &) –> class core::sequence::SequenceCouplingCreator &

create_sequence(self: pyrosetta.rosetta.core.sequence.SequenceCouplingCreator) → core::sequence::Sequence

C++: core::sequence::SequenceCouplingCreator::create_sequence() const –> class std::shared_ptr<class core::sequence::Sequence>

keyname(self: pyrosetta.rosetta.core.sequence.SequenceCouplingCreator) → str

C++: core::sequence::SequenceCouplingCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.sequence.SequenceCreator

Bases: pybind11_object

Abstract base class for a Mover factory; the Creator class is responsible for creating a particular mover class.

assign(self: pyrosetta.rosetta.core.sequence.SequenceCreator, : pyrosetta.rosetta.core.sequence.SequenceCreator) → pyrosetta.rosetta.core.sequence.SequenceCreator

C++: core::sequence::SequenceCreator::operator=(const class core::sequence::SequenceCreator &) –> class core::sequence::SequenceCreator &

create_sequence(self: pyrosetta.rosetta.core.sequence.SequenceCreator) → core::sequence::Sequence

C++: core::sequence::SequenceCreator::create_sequence() const –> class std::shared_ptr<class core::sequence::Sequence>

keyname(self: pyrosetta.rosetta.core.sequence.SequenceCreator) → str

C++: core::sequence::SequenceCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.sequence.SequenceFactory

Bases: SingletonBase_core_sequence_SequenceFactory_t

factory_register(self: pyrosetta.rosetta.core.sequence.SequenceFactory, creator: pyrosetta.rosetta.core.sequence.SequenceCreator) → None

C++: core::sequence::SequenceFactory::factory_register(class std::shared_ptr<const class core::sequence::SequenceCreator>) –> void

get_creator(self: pyrosetta.rosetta.core.sequence.SequenceFactory, type_name: str) → pyrosetta.rosetta.core.sequence.SequenceCreator

C++: core::sequence::SequenceFactory::get_creator(const std::string &) –> class std::shared_ptr<const class core::sequence::SequenceCreator>

static get_instance() → core::sequence::SequenceFactory

C++: utility::SingletonBase<core::sequence::SequenceFactory>::get_instance() –> class core::sequence::SequenceFactory *

get_seq_names(self: pyrosetta.rosetta.core.sequence.SequenceFactory) → pyrosetta.rosetta.utility.vector1_std_string

C++: core::sequence::SequenceFactory::get_seq_names() const –> class utility::vector1<std::string, class std::allocator<std::string > >

get_sequence(self: pyrosetta.rosetta.core.sequence.SequenceFactory, type_name: str) → pyrosetta.rosetta.core.sequence.Sequence

C++: core::sequence::SequenceFactory::get_sequence(const std::string &) –> class std::shared_ptr<class core::sequence::Sequence>

seq_from_file(self: pyrosetta.rosetta.core.sequence.SequenceFactory, fn: str, type_name: str) → pyrosetta.rosetta.core.sequence.Sequence

C++: core::sequence::SequenceFactory::seq_from_file(const std::string &, const std::string &) –> class std::shared_ptr<class core::sequence::Sequence>

class pyrosetta.rosetta.core.sequence.SequenceProfile

Bases: Sequence

alphabet(*args, **kwargs)

Overloaded function.

1. alphabet(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> pyrosetta.rosetta.utility.vector1_std_string

Return the alphabet used by this sequence profile. This is an

N-dimensional vector1 where N is the width of the profile, and the ith entry of any row in the profile represents the probability of ith character at that row in the sequence.

C++: core::sequence::SequenceProfile::alphabet() const –> class utility::vector1<std::string, class std::allocator<std::string > >

2. alphabet(self: pyrosetta.rosetta.core.sequence.SequenceProfile, new_alphabet: pyrosetta.rosetta.utility.vector1_std_string) -> None

C++: core::sequence::SequenceProfile::alphabet(class utility::vector1<std::string, class std::allocator<std::string > >) –> void

append_char(self: pyrosetta.rosetta.core.sequence.Sequence, new_char: str) → None

Append a character

C++: core::sequence::Sequence::append_char(char) –> void

append_gap(self: pyrosetta.rosetta.core.sequence.Sequence) → None

Append a gap

C++: core::sequence::Sequence::append_gap() –> void

assign(self: pyrosetta.rosetta.core.sequence.SequenceProfile, : pyrosetta.rosetta.core.sequence.SequenceProfile) → pyrosetta.rosetta.core.sequence.SequenceProfile

C++: core::sequence::SequenceProfile::operator=(const class core::sequence::SequenceProfile &) –> class core::sequence::SequenceProfile &

at(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → str

C++: core::sequence::Sequence::at(unsigned long) const –> char

clone(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → pyrosetta.rosetta.core.sequence.Sequence

Returns an owning pointer to a new SequenceProfile object,

with data that is a deep copy of the information in this object.

C++: core::sequence::SequenceProfile::clone() const –> class std::shared_ptr<class core::sequence::Sequence>

convert_profile_to_probs(*args, **kwargs)

Overloaded function.

1. convert_profile_to_probs(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> None

2. convert_profile_to_probs(self: pyrosetta.rosetta.core.sequence.SequenceProfile, temp: float) -> None

Use boltzman scaling on a per-residue basis to convert the current profile values to probabilities ( range 0.0-1.0 )

C++: core::sequence::SequenceProfile::convert_profile_to_probs(double) –> void

delete_position(self: pyrosetta.rosetta.core.sequence.SequenceProfile, pos: int) → None

Deletes the given position from the Sequence and shifts

everything else back by one.

C++: core::sequence::SequenceProfile::delete_position(unsigned long) –> void

gap_char(*args, **kwargs)

Overloaded function.

1. gap_char(self: pyrosetta.rosetta.core.sequence.Sequence, gap_char: str) -> None

sets gap_char to the given value.

C++: core::sequence::Sequence::gap_char(char) –> void

2. gap_char(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the character used to represent a gap for this object.

C++: core::sequence::Sequence::gap_char() const –> char

generate_from_sequence(*args, **kwargs)

Overloaded function.

1. generate_from_sequence(self: pyrosetta.rosetta.core.sequence.SequenceProfile, seq: pyrosetta.rosetta.core.sequence.Sequence) -> None

2. generate_from_sequence(self: pyrosetta.rosetta.core.sequence.SequenceProfile, seq: pyrosetta.rosetta.core.sequence.Sequence, matrix: str) -> None

Generate the profile matrix from a sequence and a given substitution matrix

C++: core::sequence::SequenceProfile::generate_from_sequence(const class core::sequence::Sequence &, std::string) –> void

global_auto_rescale(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → None

Use linear rescaling (with a fixed zero) to fit the values within the range -1.0 to 1.0

C++: core::sequence::SequenceProfile::global_auto_rescale() –> void

id(*args, **kwargs)

Overloaded function.

1. id(self: pyrosetta.rosetta.core.sequence.Sequence, new_id: str) -> None

sets id to the given value.

C++: core::sequence::Sequence::id(std::string) –> void

2. id(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the id of this object.

C++: core::sequence::Sequence::id() const –> std::string

insert_char(self: pyrosetta.rosetta.core.sequence.SequenceProfile, pos: int, new_char: str) → None

Inserts a character at the given position.

C++: core::sequence::SequenceProfile::insert_char(unsigned long, char) –> void

insert_gap(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → None

Inserts a gap at the given position, where insert_gap( 0 )

inserts the character at the beginning of the sequence, and insert_gap( length() ) inserts the character at the end of the sequence.

C++: core::sequence::Sequence::insert_gap(unsigned long) –> void

is_gap(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int) → bool

Returns true if this position in the sequence represents a gap,

returns false otherwise.

C++: core::sequence::Sequence::is_gap(unsigned long) const –> bool

length(self: pyrosetta.rosetta.core.sequence.Sequence) → int

Returns the number of characters in this object.

C++: core::sequence::Sequence::length() const –> unsigned long

negative_better(*args, **kwargs)

Overloaded function.

1. negative_better(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> bool

Returns true if negative values are better identities.

The “default” use case is for storing log likelihood values where positive is better. If you’re using this class to store energy-like values, set negative_better to true.

C++: core::sequence::SequenceProfile::negative_better() const –> bool

2. negative_better(self: pyrosetta.rosetta.core.sequence.SequenceProfile, negbet: bool) -> None

Set whether negative identities are better.

C++: core::sequence::SequenceProfile::negative_better(bool) –> void

occurrence_data(*args, **kwargs)

Overloaded function.

1. occurrence_data(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t

Returns the 2D vector1 of Real values of the probabilties of each aa.

C++: core::sequence::SequenceProfile::occurrence_data() const –> const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &

2. occurrence_data(self: pyrosetta.rosetta.core.sequence.SequenceProfile, new_occurrence_data: pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t) -> None

Sets the 2D vector1 of Real values of the probabilties of each aa.

C++: core::sequence::SequenceProfile::occurrence_data(const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &) –> void

probability_row(self: pyrosetta.rosetta.core.sequence.SequenceProfile, pos: int) → pyrosetta.rosetta.utility.vector1_double

C++: core::sequence::SequenceProfile::probability_row(unsigned long) const –> const class utility::vector1<double, class std::allocator<double> > &

probabilty_row(self: pyrosetta.rosetta.core.sequence.SequenceProfile, new_prob_row: pyrosetta.rosetta.utility.vector1_double, pos: int) → None

C++: core::sequence::SequenceProfile::probabilty_row(const class utility::vector1<double, class std::allocator<double> > &, unsigned long) –> void

prof_row(*args, **kwargs)

Overloaded function.

1. prof_row(self: pyrosetta.rosetta.core.sequence.SequenceProfile, pos: int) -> pyrosetta.rosetta.utility.vector1_double

Returns the vector1 of values at this position.

C++: core::sequence::SequenceProfile::prof_row(unsigned long) const –> const class utility::vector1<double, class std::allocator<double> > &

2. prof_row(self: pyrosetta.rosetta.core.sequence.SequenceProfile, new_prof_row: pyrosetta.rosetta.utility.vector1_double, pos: int) -> None

Sets the 1D vector1 of Real values representing this profile at pos X.

C++: core::sequence::SequenceProfile::prof_row(const class utility::vector1<double, class std::allocator<double> > &, unsigned long) –> void

profile(*args, **kwargs)

Overloaded function.

1. profile(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t

Returns the 2D vector1 of Real values representing this profile.

C++: core::sequence::SequenceProfile::profile() const –> const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &

2. profile(self: pyrosetta.rosetta.core.sequence.SequenceProfile, new_profile: pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t) -> None

Sets the 2D vector1 of Real values representing this profile.

C++: core::sequence::SequenceProfile::profile(const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &) –> void

read_data(self: pyrosetta.rosetta.core.sequence.Sequence, in: pyrosetta.rosetta.std.istream) → None

Initializes the information in this sequence from the given

std::istream. The istream should yield three pieces of information in the following order: - id - start - sequence

C++: core::sequence::Sequence::read_data(std::istream &) –> void

read_from_binary_chk(self: pyrosetta.rosetta.core.sequence.SequenceProfile, fn: pyrosetta.rosetta.utility.file.FileName) → None

Read profile matrix from the given filename in the legacy BLAST binary format

C++: core::sequence::SequenceProfile::read_from_binary_chk(const class utility::file::FileName &) –> void

read_from_checkpoint(*args, **kwargs)

Overloaded function.

1. read_from_checkpoint(self: pyrosetta.rosetta.core.sequence.SequenceProfile, fn: pyrosetta.rosetta.utility.file.FileName) -> None

2. read_from_checkpoint(self: pyrosetta.rosetta.core.sequence.SequenceProfile, fn: pyrosetta.rosetta.utility.file.FileName, negative_better: bool) -> None

Read profile matrix from the given filename using the NNMAKE

.checkpoint format. For compatability, negative_better defaults to true. Set manually if necessary.

C++: core::sequence::SequenceProfile::read_from_checkpoint(const class utility::file::FileName &, bool) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.SequenceProfile, fn: pyrosetta.rosetta.utility.file.FileName) → None

Read an profile matrix from the given filename using the NCBI

PSSM format for a position-specific scoring matrix.

C++: core::sequence::SequenceProfile::read_from_file(const class utility::file::FileName &) –> void

replace_char(self: pyrosetta.rosetta.core.sequence.Sequence, pos: int, new_char: str) → None

C++: core::sequence::Sequence::replace_char(unsigned long, char) –> void

rescale(*args, **kwargs)

Overloaded function.

1. rescale(self: pyrosetta.rosetta.core.sequence.SequenceProfile) -> None

2. rescale(self: pyrosetta.rosetta.core.sequence.SequenceProfile, factor: float) -> None

Multiply all profile weights by factor

C++: core::sequence::SequenceProfile::rescale(double) –> void

resnum(self: pyrosetta.rosetta.core.sequence.Sequence, idx: int) → int

Returns the index of the given sequence position, which is the

position in the sequence minus any gaps that occur earlier in the sequence. For example, if the sequence is —AT, resnum(5) will return 2. Returns 0 for unaligned positions.

C++: core::sequence::Sequence::resnum(unsigned long) const –> unsigned long

sequence(*args, **kwargs)

Overloaded function.

1. sequence(self: pyrosetta.rosetta.core.sequence.Sequence, sequence: str) -> None

sets sequence to the given value.

C++: core::sequence::Sequence::sequence(std::string) –> void

2. sequence(self: pyrosetta.rosetta.core.sequence.Sequence) -> str

Returns the full sequence, which may include gaps.

C++: core::sequence::Sequence::sequence() const –> std::string

size(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → int

C++: core::sequence::SequenceProfile::size() const –> unsigned long

spacer_positions(*args, **kwargs)

Overloaded function.

1. spacer_positions(self: pyrosetta.rosetta.core.sequence.Sequence, spacer_positions: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

sets spacer_positions to the given value.

C++: core::sequence::Sequence::spacer_positions(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

2. spacer_positions(self: pyrosetta.rosetta.core.sequence.Sequence) -> pyrosetta.rosetta.utility.vector1_unsigned_long

Returns the spacer positions (chain breaks, e.g., from spaces or commas in original sequence text)

C++: core::sequence::Sequence::spacer_positions() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

start(*args, **kwargs)

Overloaded function.

1. start(self: pyrosetta.rosetta.core.sequence.Sequence, new_start: int) -> None

sets starting index to the given value.

C++: core::sequence::Sequence::start(unsigned long) –> void

2. start(self: pyrosetta.rosetta.core.sequence.Sequence) -> int

Returns the start of this object.

C++: core::sequence::Sequence::start() const –> unsigned long

temp(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → float

returns the temperature used in computing profile probabilities

C++: core::sequence::SequenceProfile::temp() const –> double

to_string(self: pyrosetta.rosetta.core.sequence.Sequence) → str

C++: core::sequence::Sequence::to_string() const –> std::string

type(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → str

C++: core::sequence::SequenceProfile::type() const –> std::string

ungapped_length(self: pyrosetta.rosetta.core.sequence.Sequence) → int

Returns the number of characters in this object, ignoring gaps.

C++: core::sequence::Sequence::ungapped_length() const –> unsigned long

ungapped_sequence(self: pyrosetta.rosetta.core.sequence.Sequence) → str

Returns the string representing this sequence without gaps.

C++: core::sequence::Sequence::ungapped_sequence() const –> std::string

width(self: pyrosetta.rosetta.core.sequence.SequenceProfile) → int

Returns the number of distinct values at each position in this

profile.

C++: core::sequence::SequenceProfile::width() const –> unsigned long

class pyrosetta.rosetta.core.sequence.SequenceProfileCreator

Bases: SequenceCreator

assign(self: pyrosetta.rosetta.core.sequence.SequenceProfileCreator, : pyrosetta.rosetta.core.sequence.SequenceProfileCreator) → pyrosetta.rosetta.core.sequence.SequenceProfileCreator

C++: core::sequence::SequenceProfileCreator::operator=(const class core::sequence::SequenceProfileCreator &) –> class core::sequence::SequenceProfileCreator &

create_sequence(self: pyrosetta.rosetta.core.sequence.SequenceProfileCreator) → core::sequence::Sequence

C++: core::sequence::SequenceProfileCreator::create_sequence() const –> class std::shared_ptr<class core::sequence::Sequence>

keyname(self: pyrosetta.rosetta.core.sequence.SequenceProfileCreator) → str

C++: core::sequence::SequenceProfileCreator::keyname() const –> std::string

class pyrosetta.rosetta.core.sequence.SimpleScoringScheme

Bases: ScoringScheme

assign(self: pyrosetta.rosetta.core.sequence.SimpleScoringScheme, : pyrosetta.rosetta.core.sequence.SimpleScoringScheme) → pyrosetta.rosetta.core.sequence.SimpleScoringScheme

C++: core::sequence::SimpleScoringScheme::operator=(const class core::sequence::SimpleScoringScheme &) –> class core::sequence::SimpleScoringScheme &

clone(self: pyrosetta.rosetta.core.sequence.SimpleScoringScheme) → pyrosetta.rosetta.core.sequence.ScoringScheme

C++: core::sequence::SimpleScoringScheme::clone() const –> class std::shared_ptr<class core::sequence::ScoringScheme>

gap_extend(*args, **kwargs)

Overloaded function.

1. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend() const –> double

2. gap_extend(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_extend: float) -> None

Sets the gap extension penalty.

C++: core::sequence::ScoringScheme::gap_extend(const double) –> void

gap_open(*args, **kwargs)

Overloaded function.

1. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> float

Gets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open() const –> double

2. gap_open(self: pyrosetta.rosetta.core.sequence.ScoringScheme, gap_open: float) -> None

Sets the gap opening penalty.

C++: core::sequence::ScoringScheme::gap_open(const double) –> void

is_good(self: pyrosetta.rosetta.core.sequence.ScoringScheme, num: float) → bool

C++: core::sequence::ScoringScheme::is_good(const double &) –> bool

match_score(self: pyrosetta.rosetta.core.sequence.SimpleScoringScheme) → float

C++: core::sequence::SimpleScoringScheme::match_score() const –> double

mismatch_score(self: pyrosetta.rosetta.core.sequence.SimpleScoringScheme) → float

C++: core::sequence::SimpleScoringScheme::mismatch_score() const –> double

read_data(self: pyrosetta.rosetta.core.sequence.ScoringScheme, : pyrosetta.rosetta.utility.io.izstream) → None

C++: core::sequence::ScoringScheme::read_data(class utility::io::izstream &) –> void

read_from_file(self: pyrosetta.rosetta.core.sequence.SimpleScoringScheme, fn: pyrosetta.rosetta.utility.file.FileName) → None

C++: core::sequence::SimpleScoringScheme::read_from_file(const class utility::file::FileName &) –> void

score(self: pyrosetta.rosetta.core.sequence.SimpleScoringScheme, seq1: pyrosetta.rosetta.core.sequence.Sequence, seq2: pyrosetta.rosetta.core.sequence.Sequence, pos1: int, pos2: int) → float

C++: core::sequence::SimpleScoringScheme::score(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>, unsigned long, unsigned long) –> double

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme) -> str

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type() const –> std::string

2. type(self: pyrosetta.rosetta.core.sequence.ScoringScheme, new_type: str) -> None

getters for type, which is a unique string name for this object.

C++: core::sequence::ScoringScheme::type(std::string) –> void

unimplemented_method_error(self: pyrosetta.rosetta.core.sequence.ScoringScheme, method_name: str) → None

Utility method for producing useful error messages and exiting

from program. Declared const which is funny, because exiting the program certainly changes the state of this object! This might be replaced with exception handling if we ever start using those.

C++: core::sequence::ScoringScheme::unimplemented_method_error(const std::string &) const –> void

class pyrosetta.rosetta.core.sequence.SimpleSequenceCreator

Bases: SequenceCreator

assign(self: pyrosetta.rosetta.core.sequence.SimpleSequenceCreator, : pyrosetta.rosetta.core.sequence.SimpleSequenceCreator) → pyrosetta.rosetta.core.sequence.SimpleSequenceCreator

C++: core::sequence::SimpleSequenceCreator::operator=(const class core::sequence::SimpleSequenceCreator &) –> class core::sequence::SimpleSequenceCreator &

create_sequence(self: pyrosetta.rosetta.core.sequence.SimpleSequenceCreator) → core::sequence::Sequence

C++: core::sequence::SimpleSequenceCreator::create_sequence() const –> class std::shared_ptr<class core::sequence::Sequence>

keyname(self: pyrosetta.rosetta.core.sequence.SimpleSequenceCreator) → str

C++: core::sequence::SimpleSequenceCreator::keyname() const –> std::string

pyrosetta.rosetta.core.sequence.align_naive(seq1: pyrosetta.rosetta.core.sequence.Sequence, seq2: pyrosetta.rosetta.core.sequence.Sequence) → pyrosetta.rosetta.core.sequence.SequenceAlignment

Generate a naive sequence alignment between two sequences.

C++: core::sequence::align_naive(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>) –> class core::sequence::SequenceAlignment

pyrosetta.rosetta.core.sequence.align_poses_naive(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.sequence.SequenceAlignment

C++: core::sequence::align_poses_naive(class core::pose::Pose &, class core::pose::Pose &) –> class core::sequence::SequenceAlignment

pyrosetta.rosetta.core.sequence.alignment_from_pose(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.sequence.SequenceAlignment

C++: core::sequence::alignment_from_pose(class core::pose::Pose &) –> class core::sequence::SequenceAlignment

pyrosetta.rosetta.core.sequence.alignment_into_pose(aln: pyrosetta.rosetta.core.sequence.SequenceAlignment, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::sequence::alignment_into_pose(const class core::sequence::SequenceAlignment &, class core::pose::Pose &) –> void

pyrosetta.rosetta.core.sequence.calpha_superimpose_with_mapping(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, mapping: pyrosetta.rosetta.core.id.SequenceMapping) → float

C++: core::sequence::calpha_superimpose_with_mapping(class core::pose::Pose &, const class core::pose::Pose &, const class core::id::SequenceMapping &) –> double

pyrosetta.rosetta.core.sequence.convert_to_fasta(pname: str, seq: str) → str

C++: core::sequence::convert_to_fasta(const std::string &, const std::string &) –> std::string

pyrosetta.rosetta.core.sequence.create_fasta_file(pname: str, seq: str) → str

C++: core::sequence::create_fasta_file(const std::string &, const std::string &) –> std::string

pyrosetta.rosetta.core.sequence.create_map_for_Blosum62Map() → pyrosetta.rosetta.std.unordered_map_std_pair_char_char_int_core_sequence_CharPairHash_std_equal_to_std_pair_char_char_std_allocator_std_pair_const_std_pair_char_char_int_t

C++: core::sequence::create_map_for_Blosum62Map() –> class std::unordered_map<struct std::pair<char, char>, int, struct core::sequence::CharPairHash, struct std::equal_to<struct std::pair<char, char> >, class std::allocator<struct std::pair<const struct std::pair<char, char>, int> > >

pyrosetta.rosetta.core.sequence.get_abego(*args, **kwargs)

Overloaded function.

1. get_abego(pose: core::pose::Pose) -> pyrosetta.rosetta.utility.vector1_std_string

2. get_abego(pose: core::pose::Pose, level: int) -> pyrosetta.rosetta.utility.vector1_std_string

utility for getting abego

C++: core::sequence::get_abego(const class core::pose::Pose &, const unsigned long) –> class utility::vector1<std::string, class std::allocator<std::string > >

pyrosetta.rosetta.core.sequence.get_design_sequence_motif_syntax() → str

Return the description of the syntax for a design sequence motif.

C++: core::sequence::get_design_sequence_motif_syntax() –> std::string

pyrosetta.rosetta.core.sequence.get_maximum_scores(ss: pyrosetta.rosetta.core.sequence.ScoringScheme, seq: pyrosetta.rosetta.core.sequence.Sequence) → pyrosetta.rosetta.utility.vector1_double

C++: core::sequence::get_maximum_scores(class std::shared_ptr<class core::sequence::ScoringScheme>, class std::shared_ptr<class core::sequence::Sequence>) –> class utility::vector1<double, class std::allocator<double> >

pyrosetta.rosetta.core.sequence.get_motif_length(motif: str) → int

C++: core::sequence::get_motif_length(const std::string &) –> unsigned long

pyrosetta.rosetta.core.sequence.map_seq1_seq2(seq1: pyrosetta.rosetta.core.sequence.Sequence, seq2: pyrosetta.rosetta.core.sequence.Sequence) → pyrosetta.rosetta.core.id.SequenceMapping

Generates a mapping of sequence 1 onto sequence 2 using dynamic

programming with a simple scoring framework.

C++: core::sequence::map_seq1_seq2(class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>) –> class core::id::SequenceMapping

pyrosetta.rosetta.core.sequence.mapping_to_alignment(mapping: pyrosetta.rosetta.core.id.SequenceMapping, seq1: pyrosetta.rosetta.core.sequence.Sequence, seq2: pyrosetta.rosetta.core.sequence.Sequence) → pyrosetta.rosetta.core.sequence.SequenceAlignment

Constructs a SequenceAlignment from the given SequenceMapping and

the two sequences.

C++: core::sequence::mapping_to_alignment(const class core::id::SequenceMapping &, class std::shared_ptr<class core::sequence::Sequence>, class std::shared_ptr<class core::sequence::Sequence>) –> class core::sequence::SequenceAlignment

pyrosetta.rosetta.core.sequence.n_correctly_aligned_positions(candidate_aln: pyrosetta.rosetta.core.sequence.SequenceAlignment, true_aln: pyrosetta.rosetta.core.sequence.SequenceAlignment) → int

C++: core::sequence::n_correctly_aligned_positions(class core::sequence::SequenceAlignment &, class core::sequence::SequenceAlignment &) –> unsigned long

pyrosetta.rosetta.core.sequence.output_fasta_file(fasta_filename: str, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::sequence::output_fasta_file(const std::string &, const class core::pose::Pose &) –> void

pyrosetta.rosetta.core.sequence.parse_out_non_standard_residues(*args, **kwargs)

Overloaded function.

1. parse_out_non_standard_residues(fasta_sequences: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_sequence_Sequence_t) -> pyrosetta.rosetta.std.map_unsigned_long_std_string

C++: core::sequence::parse_out_non_standard_residues(class utility::vector1<class std::shared_ptr<class core::sequence::Sequence>, class std::allocator<class std::shared_ptr<class core::sequence::Sequence> > > &) –> class std::map<unsigned long, std::string, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, std::string > > >

2. parse_out_non_standard_residues(sequence: str) -> pyrosetta.rosetta.std.map_unsigned_long_std_string

C++: core::sequence::parse_out_non_standard_residues(std::string &) –> class std::map<unsigned long, std::string, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, std::string > > >

pyrosetta.rosetta.core.sequence.read_alignment_file(filename: str, seq1: str, seq2: str, mapping: pyrosetta.rosetta.core.sequence.DerivedSequenceMapping) → None

helper function for reading a SequenceMapping from an alignment

file.

C++: core::sequence::read_alignment_file(const std::string &, std::string &, std::string &, class core::sequence::DerivedSequenceMapping &) –> void

pyrosetta.rosetta.core.sequence.read_all_alignments(format: str, files: pyrosetta.rosetta.utility.vector1_std_string, alignments: pyrosetta.rosetta.utility.vector1_core_sequence_SequenceAlignment) → None

Populates the non-null vector <alignments> with all of the sequence

alignments found in <files>. Each alignment is required to have format <format>.

C++: core::sequence::read_all_alignments(const std::string &, const class utility::vector1<std::string, class std::allocator<std::string > > &, class utility::vector1<class core::sequence::SequenceAlignment, class std::allocator<class core::sequence::SequenceAlignment> > &) –> void

pyrosetta.rosetta.core.sequence.read_aln(format: str, filename: str) → pyrosetta.rosetta.utility.vector1_core_sequence_SequenceAlignment

C++: core::sequence::read_aln(const std::string &, const std::string &) –> class utility::vector1<class core::sequence::SequenceAlignment, class std::allocator<class core::sequence::SequenceAlignment> >

pyrosetta.rosetta.core.sequence.read_fasta_file(filename: str) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_sequence_Sequence_t

Read in sequences from a fasta-formatted file.

C++: core::sequence::read_fasta_file(const std::string &) –> class utility::vector1<class std::shared_ptr<class core::sequence::Sequence>, class std::allocator<class std::shared_ptr<class core::sequence::Sequence> > >

pyrosetta.rosetta.core.sequence.read_fasta_file_and_concatenate(filename: str) → str

Read fasta file and concatenate sequences

C++: core::sequence::read_fasta_file_and_concatenate(const std::string &) –> std::string

pyrosetta.rosetta.core.sequence.read_fasta_file_return_str(filename: str) → str

C++: core::sequence::read_fasta_file_return_str(const std::string &) –> std::string

pyrosetta.rosetta.core.sequence.read_fasta_file_section(filename: str, section: str) → str

read sequence from particular section of fasta file (comment starting with ‘> section’), terminate with failure if section not found

Note: section detection string is case insensitive

C++: core::sequence::read_fasta_file_section(const std::string &, const std::string &) –> std::string

pyrosetta.rosetta.core.sequence.read_fasta_file_str(filename: str) → pyrosetta.rosetta.utility.vector1_std_string

C++: core::sequence::read_fasta_file_str(const std::string &) –> class utility::vector1<std::string, class std::allocator<std::string > >

pyrosetta.rosetta.core.sequence.read_general_aln(input: pyrosetta.rosetta.std.istream) → pyrosetta.rosetta.utility.vector1_core_sequence_SequenceAlignment

read generalized alignment format.

C++: core::sequence::read_general_aln(std::istream &) –> class utility::vector1<class core::sequence::SequenceAlignment, class std::allocator<class core::sequence::SequenceAlignment> >

pyrosetta.rosetta.core.sequence.read_general_aln_file(filename: str) → pyrosetta.rosetta.utility.vector1_core_sequence_SequenceAlignment

C++: core::sequence::read_general_aln_file(const std::string &) –> class utility::vector1<class core::sequence::SequenceAlignment, class std::allocator<class core::sequence::SequenceAlignment> >

pyrosetta.rosetta.core.sequence.read_grishin_aln_file(filename: str) → pyrosetta.rosetta.utility.vector1_core_sequence_SequenceAlignment

C++: core::sequence::read_grishin_aln_file(const std::string &) –> class utility::vector1<class core::sequence::SequenceAlignment, class std::allocator<class core::sequence::SequenceAlignment> >

pyrosetta.rosetta.core.sequence.seqs_from_cmd_lines() → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_sequence_Sequence_t

C++: core::sequence::seqs_from_cmd_lines() –> class utility::vector1<class std::shared_ptr<class core::sequence::Sequence>, class std::allocator<class std::shared_ptr<class core::sequence::Sequence> > >

pyrosetta.rosetta.core.sequence.simple_mapping_from_file(filename: str) → pyrosetta.rosetta.core.sequence.DerivedSequenceMapping

Read in a SequenceMapping from a file. File

format is super-simple, it just contains single lines like this that claim that residue resi and resj are aligned: resi resj

C++: core::sequence::simple_mapping_from_file(const std::string &) –> class core::sequence::DerivedSequenceMapping

pyrosetta.rosetta.core.sequence.split_sequence_motif(motif: str) → pyrosetta.rosetta.utility.vector1_std_string

Splits the sequence motif (Ex. N[^P]-[STN]A) into strings of commands for individual positions

Example: [“N”, “^P”, “-”, “STN”,”A”,] for the three positions specified

C++: core::sequence::split_sequence_motif(const std::string &) –> class utility::vector1<std::string, class std::allocator<std::string > >

pyrosetta.rosetta.core.sequence.steal_alignment(aln_to_steal: pyrosetta.rosetta.core.sequence.SequenceAlignment, seqs: pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_sequence_Sequence_t) → pyrosetta.rosetta.core.sequence.SequenceAlignment

takes the sequences in the provided vector1 and makes them match

the alignment in aln_to_steal by matching gaps. This assumes that the ungapped sequences at index j in the vector1< SequenceOP > match the ungapped sequences at index j in aln_to_steal.

C++: core::sequence::steal_alignment(class core::sequence::SequenceAlignment, class utility::vector1<class std::shared_ptr<class core::sequence::Sequence>, class std::allocator<class std::shared_ptr<class core::sequence::Sequence> > >) –> class core::sequence::SequenceAlignment

pyrosetta.rosetta.core.sequence.strip_spacers(*args, **kwargs)

Overloaded function.

1. strip_spacers(sequence: str) -> pyrosetta.rosetta.utility.vector1_unsigned_long

2. strip_spacers(sequence: str, annotations_in_brackets: bool) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: core::sequence::strip_spacers(std::string &, const bool) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.sequence.transitive_map(map1: pyrosetta.rosetta.core.id.SequenceMapping, map2: pyrosetta.rosetta.core.id.SequenceMapping) → pyrosetta.rosetta.core.id.SequenceMapping

Assuming that map1 maps sequence A to sequence B, and map2 maps

sequence B to sequence C, this function returns the SequenceMapping representing the direct map of sequence A to sequence C.

C++: core::sequence::transitive_map(const class core::id::SequenceMapping &, const class core::id::SequenceMapping &) –> class core::id::SequenceMapping