bin_transitions¶

Bindings for core::scoring::bin_transitions namespace

class pyrosetta.rosetta.core.scoring.bin_transitions.BTSB_SUBBIN_TYPE¶

Bases: pybind11_object

Enum for the way in which bins will be divided into subbins.

Default is BTSB_NONE, which means that the bin has no subbins. As subbin types are

added, add them (1) here, and (2) to the get_subbin_type_name function, and (3) to the setup_subbin_type function, then add a function called by the setup_subbin_type function.

Members:

BTSB_NONE

BTSB_L_AA

BTSB_D_AA

BTSB_L_PRO

BTSB_D_PRO

BTSB_GLY

BTSB_UNKNOWN

BTSB_END_OF_LIST

BTSB_D_AA = <BTSB_SUBBIN_TYPE.BTSB_D_AA: 3>¶

BTSB_D_PRO = <BTSB_SUBBIN_TYPE.BTSB_D_PRO: 5>¶

BTSB_END_OF_LIST = <BTSB_SUBBIN_TYPE.BTSB_END_OF_LIST: 8>¶

BTSB_GLY = <BTSB_SUBBIN_TYPE.BTSB_GLY: 6>¶

BTSB_L_AA = <BTSB_SUBBIN_TYPE.BTSB_L_AA: 2>¶

BTSB_L_PRO = <BTSB_SUBBIN_TYPE.BTSB_L_PRO: 4>¶

BTSB_NONE = <BTSB_SUBBIN_TYPE.BTSB_NONE: 1>¶

BTSB_UNKNOWN = <BTSB_SUBBIN_TYPE.BTSB_UNKNOWN: 7>¶

property name¶

property value¶

class pyrosetta.rosetta.core.scoring.bin_transitions.BT_PROPERTIES¶

Bases: pybind11_object

Enum for the properties that can be required or prohibited at the i or i+1 position.

These reflect properties that residues can have. Whenever a property is added, add it (1) here, (2) to the get_property_effect_name function, and (3) to the has_property function.

Members:

BT_PROTEIN

BT_L_AA

BT_D_AA

BT_ALPHA_AA

BT_BETA_AA

BT_POLAR

BT_METALBINDING

BT_CHARGED

BT_AROMATIC

BT_DISULFIDE_BONDED

BT_SIDECHAIN_THIOL

BT_CYCLIC

BT_UNKNOWN_PROPERTY

BT_END_OF_LIST

BT_ALPHA_AA = <BT_PROPERTIES.BT_ALPHA_AA: 4>¶

BT_AROMATIC = <BT_PROPERTIES.BT_AROMATIC: 9>¶

BT_BETA_AA = <BT_PROPERTIES.BT_BETA_AA: 5>¶

BT_CHARGED = <BT_PROPERTIES.BT_CHARGED: 8>¶

BT_CYCLIC = <BT_PROPERTIES.BT_CYCLIC: 12>¶

BT_DISULFIDE_BONDED = <BT_PROPERTIES.BT_DISULFIDE_BONDED: 10>¶

BT_D_AA = <BT_PROPERTIES.BT_D_AA: 3>¶

BT_END_OF_LIST = <BT_PROPERTIES.BT_END_OF_LIST: 14>¶

BT_L_AA = <BT_PROPERTIES.BT_L_AA: 2>¶

BT_METALBINDING = <BT_PROPERTIES.BT_METALBINDING: 7>¶

BT_POLAR = <BT_PROPERTIES.BT_POLAR: 6>¶

BT_PROTEIN = <BT_PROPERTIES.BT_PROTEIN: 1>¶

BT_SIDECHAIN_THIOL = <BT_PROPERTIES.BT_SIDECHAIN_THIOL: 11>¶

BT_UNKNOWN_PROPERTY = <BT_PROPERTIES.BT_UNKNOWN_PROPERTY: 13>¶

property name¶

property value¶

class pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, : pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator) → pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator¶: C++: core::scoring::bin_transitions::BinTransitionCalculator::operator=(const class core::scoring::bin_transitions::BinTransitionCalculator &) –> class core::scoring::bin_transitions::BinTransitionCalculator &

bin_definition_exists(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, name: str) → bool¶

Is a particular bin defined for at least one residue type?

C++: core::scoring::bin_transitions::BinTransitionCalculator::bin_definition_exists(const std::string &) const –> bool

bin_params_loaded(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator) → bool¶

Return whether the bin params file has been loaded.

C++: core::scoring::bin_transitions::BinTransitionCalculator::bin_params_loaded() const –> bool

clone(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator) → pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator¶

Clone operation for BinTransitionCalculator.

Returns an owning pointer to a copy of this object.

C++: core::scoring::bin_transitions::BinTransitionCalculator::clone() const –> class std::shared_ptr<class core::scoring::bin_transitions::BinTransitionCalculator>

find_data(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, res_i: pyrosetta.rosetta.core.conformation.Residue, res_iplus1: pyrosetta.rosetta.core.conformation.Residue, data_index: int) → bool¶

Given residues at positions i and iplus1, find a bin transition probability data object that

describes the pair.

Inputs are res_i and res_iplus1. Outputs are data_i and data_iplus1 (BinTransitionData indices). Function returns true if data are found successfully, false if no BinTransitionData object could be found describing the residues in question.

C++: core::scoring::bin_transitions::BinTransitionCalculator::find_data(const class core::conformation::Residue &, const class core::conformation::Residue &, unsigned long &) const –> bool

find_data_and_bin(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, bin_name: str, res: pyrosetta.rosetta.core.conformation.Residue, data_index: int, bin_index: int, use_iplus1: bool) → None¶

Given a bin name and a residue, find a BinTransitionsData object describing that residue,

and the index of the bin within that object.

data_index and bin_index are outputs. Both are set to 0 if the search fails. Everything else is const input. If bin_name is set to “”, then the bin index that is returned is the index corresponding to the residue’s mainchain torsion vector.

C++: core::scoring::bin_transitions::BinTransitionCalculator::find_data_and_bin(const std::string &, const class core::conformation::Residue &, unsigned long &, unsigned long &, const bool) const –> void

is_in_bin(*args, **kwargs)¶

Overloaded function.

is_in_bin(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, res: pyrosetta.rosetta.core.conformation.Residue, bin_name: str) -> bool

Is the given residue in the given bin?

For the bin definitions, this uses the first BinTransitionsData object that it finds where residue i matches the properties of the given residue. Checks the i+1 definitions if nothing is found for the i transitions. Fails if no bin definitions for the given residue type are found.

C++: core::scoring::bin_transitions::BinTransitionCalculator::is_in_bin(const class core::conformation::Residue &, const std::string &) const –> bool

is_in_bin(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, res: pyrosetta.rosetta.core.conformation.Residue, data_index: int, bin_index: int, use_iplus1: bool) -> bool

Is the given residue in the bin given by a data object index and a bin index?

C++: core::scoring::bin_transitions::BinTransitionCalculator::is_in_bin(const class core::conformation::Residue &, const unsigned long, const unsigned long, const bool) const –> bool

load_bin_params(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, filename: str) → None¶

Set the bin params file, and load all the bin params and transition probabilities.

Triggers read from disk!

C++: core::scoring::bin_transitions::BinTransitionCalculator::load_bin_params(const std::string &) –> void

n_bin_transition_data(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator) → int¶

Number of BinTransitionData objects stored (i.e. number of transition probability matrices stored).

C++: core::scoring::bin_transitions::BinTransitionCalculator::n_bin_transition_data() const –> unsigned long

p_i_given_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, rsd_i: pyrosetta.rosetta.core.conformation.Residue, rsd_iplus1: pyrosetta.rosetta.core.conformation.Residue, probability: float) → bool¶

Given two residues (rsd_i and rsd_iplus1 at positions i and i+1, respectively), give me the

probability of seeing rsd_i in its bin given that rsd_iplus1 is in its bin.

The probability value is set to a number from 0 to 1. Inputs are rsd_i and rsd_iplus1. Function returns true if data are found successfully, false if no BinTransitionData object could be found describing the residues in question.

C++: core::scoring::bin_transitions::BinTransitionCalculator::p_i_given_iplus1(const class core::conformation::Residue &, const class core::conformation::Residue &, double &) const –> bool

p_iplus1_given_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, rsd_i: pyrosetta.rosetta.core.conformation.Residue, rsd_iplus1: pyrosetta.rosetta.core.conformation.Residue, probability: float) → bool¶

Given two residues (rsd_i and rsd_iplus1 at positions i and i+1, respectively), give me the

probability of seeing rsd_iplus1 in its bin given that rsd_i is in its bin.

The probability value is set to a number from 0 to 1. Inputs are rsd_i and rsd_iplus1. Function returns true if data are found successfully, false if no BinTransitionData object could be found describing the residues in question.

C++: core::scoring::bin_transitions::BinTransitionCalculator::p_iplus1_given_i(const class core::conformation::Residue &, const class core::conformation::Residue &, double &) const –> bool

random_bin(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, res: pyrosetta.rosetta.core.conformation.Residue, iplus1: bool, data_index: int) → int¶

Randomly pick a bin, given an input residue.

The residue’s properties and name are used to find the first BinTransitionData object matching the properties and name. A random bin is then picked based on the frequency with which that bin is observed for that class of residues. If the bin ends up being from the i+1st residue, iplus1 is set to “true”; otherwise, it remains “false”. The data_index variable is set by this function to the index of the BinTransitionData object that provides the transition probability data.

C++: core::scoring::bin_transitions::BinTransitionCalculator::random_bin(const class core::conformation::Residue &, bool &, unsigned long &) const –> unsigned long

random_bin_based_on_prev_and_next(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, conformation: pyrosetta.rosetta.core.conformation.Conformation, res_index: int, must_switch_bins: bool, data_index_i: int, data_index_iplus1: int) → int¶

Given the current residue and its conformation, pick a bin for the current residue based on the bins of the previous and

next residues, and the bin transition probabilities.

Bin transition probabilities are assumed to be independent. That is, P(ABC) = P(B | A & C) = P (B | A ) * P(B | C). This function also finds and returns the indices of the BinTransitionData objects that describe the AB transition (data_index_iplus1) and the BC transition (data_index_i). So conformation and res_index are const inputs, and data_index_i and data_index_iplus1 are outputs. If must_switch_bins is true, then the current bin for the current residue is never chosen; otherwise, it is in the pool to be picked.

C++: core::scoring::bin_transitions::BinTransitionCalculator::random_bin_based_on_prev_and_next(const class core::conformation::Conformation &, const unsigned long, const bool, unsigned long &, unsigned long &) const –> unsigned long

random_bin_based_on_previous(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, thisres: pyrosetta.rosetta.core.conformation.Residue, prevres: pyrosetta.rosetta.core.conformation.Residue, prev_torsions: pyrosetta.rosetta.utility.vector1_double, data_index: int) → int¶

Given the current residue and the previous residue, as well as the mainchain torsion values for the previous residue,

pick a bin for the current residue based on bin transition probabilities.

This function takes thisres (the current residue) and prevres (the previous residue) as inputs, using them for their properties and identities to find a BinTransitionData object that matches the criteria at the i and i+1st residues. It then sets data_index to the index of that BinTransitionData object before returning the index of a bin chosen for the current (i+1st) residue at random, based on the relative probabilities of bins given the previous (ith) residue.

C++: core::scoring::bin_transitions::BinTransitionCalculator::random_bin_based_on_previous(const class core::conformation::Residue &, const class core::conformation::Residue &, const class utility::vector1<double, class std::allocator<double> > &, unsigned long &) const –> unsigned long

random_mainchain_torsions_from_bin(*args, **kwargs)¶

Overloaded function.

random_mainchain_torsions_from_bin(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, bin_name: str, conformation: pyrosetta.rosetta.core.conformation.Conformation, res_indices: pyrosetta.rosetta.utility.vector1_unsigned_long, mainchain_torsions: pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t) -> None

Draw random mainchain torsion values for a set of residues, given a bin from which the values should be drawn.

Takes a bin name, a const conformation, and a const list of residue indices as input; the conformation is just for checking residues types, numbers of mainchain torsions, etc. Output is the mainchain_torsions vector of vectors (reset and replaced by this operation). The distribution WITHIN the bin depends on the BinTransitionData object and what was specified in the bin_params file. Default is uniform within each bin, though Ramachandran-biased distributions are also permitted for alpha-amino acids. Note that this function uses bins for residue i, and only checks i+1 if no suitable data are found for i.

C++: core::scoring::bin_transitions::BinTransitionCalculator::random_mainchain_torsions_from_bin(const std::string &, const class core::conformation::Conformation &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &) const –> void

random_mainchain_torsions_from_bin(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, bin_index: int, iplus1: bool, data_index: int, mainchain_torsions: pyrosetta.rosetta.utility.vector1_double) -> None

Randomly pick mainchain torsion values from within a bin

The residue’s properties and name are used to find the first BinTransitionData object matching the properties and name. Mainchain torsion values are then picked randomly from within the bin. The distribution WITHIN the bin depends on the BinTransitionData object and what was specified in the bin_params file. Default is uniform within each bin, though Ramachandran-biased distributions are also permitted for alpha-amino acids. If iplus1 is true, we draw from the bins for the i+1st residue; otherwise, we draw from the bins for the ith residue. The data_index value tells this function which BinTransitionData object to use.

C++: core::scoring::bin_transitions::BinTransitionCalculator::random_mainchain_torsions_from_bin(const unsigned long, const bool, const unsigned long, class utility::vector1<double, class std::allocator<double> > &) const –> void

random_mainchain_torsions_from_bins(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, conformation: pyrosetta.rosetta.core.conformation.Conformation, res_indices: pyrosetta.rosetta.utility.vector1_unsigned_long, mainchain_torsions: pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t) → None¶

Initialize a string of residues to a bunch of random bins, based on bin transition probabilities; then draw random mainchain torsion angles from those bins.

Takes a const conformation and a const list of residue indices as input; the conformation is just for checking residues types, numbers of mainchain torsions, etc. The residue indices must be in order, defining a contiguous chain (running backwards or forwards). Output is the mainchain_torsions vector of vectors (reset and replaced by this operation). The distribution WITHIN the bin depends on the BinTransitionData object and what was specified in the bin_params file. Default is uniform within each bin, though Ramachandran-biased distributions are also permitted for alpha-amino acids.

C++: core::scoring::bin_transitions::BinTransitionCalculator::random_mainchain_torsions_from_bins(const class core::conformation::Conformation &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &) const –> void

random_mainchain_torsions_using_adjacent_bins(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, conformation: pyrosetta.rosetta.core.conformation.Conformation, res_index: int, must_switch_bins: bool, mainchain_torsions: pyrosetta.rosetta.utility.vector1_double) → None¶

Randomly pick mainchain torsions for a residue based on the torsion bins of its i+1 and i-1 neighbours.

Takes a const conformatoin, a const residue index, and a boolean valueas input. The conformation is for checking residue types, numbers of mainchain torsions, etc. The boolean determines whether this residue should be allowed to stay in its own bin or be required to switch to another bin. Output is the mainchain_torsions vector of Reals, with one entry for each mainchain torsion of the residue.

C++: core::scoring::bin_transitions::BinTransitionCalculator::random_mainchain_torsions_using_adjacent_bins(const class core::conformation::Conformation &, const unsigned long, const bool, class utility::vector1<double, class std::allocator<double> > &) const –> void

summarize_stored_data(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator, verbose: bool) → str¶

Prints a report summarizing the data stored in this object, including

all of the BinTransitionData objects.

If verbose is true, the full sub-bin information is printed, too.

C++: core::scoring::bin_transitions::BinTransitionCalculator::summarize_stored_data(const bool) const –> std::string

class pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculatorManager¶

Bases: SingletonBase_core_scoring_bin_transitions_BinTransitionCalculatorManager_t

A static singleton that ensures that BinTransitionCalculators load data from disk once, lazily, and in a threadsafe manner.

Vikram K. Mulligan (vmulligan.org)

get_bin_transition_calculator(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculatorManager, bin_transitions_file: str) → pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionCalculator¶

Given a bin transition file, get a bin transition calculator.

If we’ve already loaded the file and created a calculator from it, then we have cached the calculator and can return a clone to it. Otherwise, we create the calculator, cache it, and return a clone to it.

Fully threadsafe.

C++: core::scoring::bin_transitions::BinTransitionCalculatorManager::get_bin_transition_calculator(const std::string &) const –> class std::shared_ptr<const class core::scoring::bin_transitions::BinTransitionCalculator>

static get_instance() → core::scoring::bin_transitions::BinTransitionCalculatorManager¶: C++: utility::SingletonBase<core::scoring::bin_transitions::BinTransitionCalculatorManager>::get_instance() –> class core::scoring::bin_transitions::BinTransitionCalculatorManager *

class pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData¶

Bases: pybind11_object

add_property_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, property: str) → None¶

Add a property to the list of properties that the ith residue MUST have.

C++: core::scoring::bin_transitions::BinTransitionData::add_property_i(const std::string &) –> void

add_property_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, property: str) → None¶

Add a property to the list of properties that the i+1st residue MUST have.

C++: core::scoring::bin_transitions::BinTransitionData::add_property_iplus1(const std::string &) –> void

add_res_identity_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, resname: str) → None¶

Add a residue identity to the list of residue identities that the ith residue MUST have.

If the list is left empty, the residue identities can be anything. Residue names are provided as three-letter codes.

C++: core::scoring::bin_transitions::BinTransitionData::add_res_identity_i(const std::string &) –> void

add_res_identity_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, resname: str) → None¶

Add a residue identity to the list of residue identities that the i+1st residue MUST have.

If the list is left empty, the residue identities can be anything. Residue names are provided as three-letter codes.

C++: core::scoring::bin_transitions::BinTransitionData::add_res_identity_iplus1(const std::string &) –> void

assign(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, : pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData¶: C++: core::scoring::bin_transitions::BinTransitionData::operator=(const class core::scoring::bin_transitions::BinTransitionData &) –> class core::scoring::bin_transitions::BinTransitionData &

bin_boundaries_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, n: int, m: int) → Tuple[float, float]¶

Get the bin start and end boundaries, in degrees, for the nth bin and the mth mainchain torsion for residue i.

If the end is less than the start, it means that the bin runs through 180 degrees and wraps around.

C++: core::scoring::bin_transitions::BinTransitionData::bin_boundaries_i(const unsigned long, const unsigned long) const –> struct std::pair<double, double>

bin_boundaries_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, n: int, m: int) → Tuple[float, float]¶

Get the bin start and end boundaries, in degrees, for the nth bin and the mth mainchain torsion for residue i+1.

If the end is less than the start, it means that the bin runs through 180 degrees and wraps around.

C++: core::scoring::bin_transitions::BinTransitionData::bin_boundaries_iplus1(const unsigned long, const unsigned long) const –> struct std::pair<double, double>

bin_exists(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, name: str) → bool¶

Does a bin with the specified name exist?

C++: core::scoring::bin_transitions::BinTransitionData::bin_exists(const std::string &) const –> bool

bin_exists_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, name: str) → bool¶

Does a bin with the specified name exist, defined for the ith residue?

C++: core::scoring::bin_transitions::BinTransitionData::bin_exists_i(const std::string &) const –> bool

bin_exists_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, name: str) → bool¶

Does a bin with the specified name exist, defined for the i+1st residue?

C++: core::scoring::bin_transitions::BinTransitionData::bin_exists_iplus1(const std::string &) const –> bool

binname_index_from_string_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin_name: str) → int¶

Given a bin name, get the bin index.

Returns 0 if the name is not found. Checks the list of bin names for the ith residue.

C++: core::scoring::bin_transitions::BinTransitionData::binname_index_from_string_i(const std::string &) const –> unsigned long

binname_index_from_string_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin_name: str) → int¶

Given a bin name, get the bin index.

Returns 0 if the name is not found. Checks the list of bin names for the i+1st residue.

C++: core::scoring::bin_transitions::BinTransitionData::binname_index_from_string_iplus1(const std::string &) const –> unsigned long

binsums_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin_index_i: int) → float¶

Get the sum of a row of the probability matrix.

This is the sum of all counts(bin_i, bin_iplus1), summed across all bin_iplus1. This is pre-calculated and stored, so this is a fast lookup.

C++: core::scoring::bin_transitions::BinTransitionData::binsums_i(const unsigned long) const –> double

binsums_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin_index_iplus1: int) → float¶

Get the sum of a column of the probability matrix.

This is the sum of all counts(bin_i, bin_iplus1), summed across all bin_i. This is pre-calculated and stored, so this is a fast lookup.

C++: core::scoring::bin_transitions::BinTransitionData::binsums_iplus1(const unsigned long) const –> double

check_property_overlap(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → None¶

Checks through the required and prohibited properties lists, and asserts that there is no overlap.

Throws an error if there is overlap.

C++: core::scoring::bin_transitions::BinTransitionData::check_property_overlap() const –> void

check_residentity_overlap(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → None¶

Checks through the required and prohibited residue identities lists, and asserts that there is no overlap.

Throws an error if there is overlap.

C++: core::scoring::bin_transitions::BinTransitionData::check_residentity_overlap() const –> void

clone(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData¶

Clone operation for BinTransitionData.

Returns an owning pointer to a copy of this object.

C++: core::scoring::bin_transitions::BinTransitionData::clone() const –> class std::shared_ptr<class core::scoring::bin_transitions::BinTransitionData>

copy_i_bins_to_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → None¶

Copy the bin names and torsion ranges for residue i to those for residue i+1.

C++: core::scoring::bin_transitions::BinTransitionData::copy_i_bins_to_iplus1() –> void

criteria_match_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, rsd: pyrosetta.rosetta.core.conformation.Residue) → bool¶

Given a residue, check whether its properties match the required and prohibited properties lists for residue i,: and whether its name matches the required and prohibited names list for residue i.

C++: core::scoring::bin_transitions::BinTransitionData::criteria_match_i(const class core::conformation::Residue &) const –> bool

criteria_match_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, rsd: pyrosetta.rosetta.core.conformation.Residue) → bool¶

Given a residue, check whether its properties match the required and prohibited properties lists for residue i+1,: and whether its name matches the required and prohibited names list for residue i+1.

C++: core::scoring::bin_transitions::BinTransitionData::criteria_match_iplus1(const class core::conformation::Residue &) const –> bool

finalize(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → None¶

Do final post-load calculations (e.g. precomputing the sum of the transition probability matrix entries,: the sum of the columns, the sum of the rows, etc.)

C++: core::scoring::bin_transitions::BinTransitionData::finalize() –> void

get_property_effect_name(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, property: pyrosetta.rosetta.core.scoring.bin_transitions.BT_PROPERTIES) → str¶

Given a property enum value, return the property name as it would appear in a: residue params file.

C++: core::scoring::bin_transitions::BinTransitionData::get_property_effect_name(const enum core::scoring::bin_transitions::BT_PROPERTIES) const –> std::string

get_property_from_name(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, name: str) → pyrosetta.rosetta.core.scoring.bin_transitions.BT_PROPERTIES¶

Given a property name, return the property enum value.

Returns BT_UNKNOWN_PROPERTY if not identifiable.

C++: core::scoring::bin_transitions::BinTransitionData::get_property_from_name(const std::string &) const –> enum core::scoring::bin_transitions::BT_PROPERTIES

get_subbin_type_from_name(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, name: str) → pyrosetta.rosetta.core.scoring.bin_transitions.BTSB_SUBBIN_TYPE¶

Given a sub-bin type name, return the sub-bin type enum value.

Returns BTSB_UNKNOWN if not identifiable.

C++: core::scoring::bin_transitions::BinTransitionData::get_subbin_type_from_name(const std::string &) const –> enum core::scoring::bin_transitions::BTSB_SUBBIN_TYPE

get_subbin_type_name(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, type: pyrosetta.rosetta.core.scoring.bin_transitions.BTSB_SUBBIN_TYPE) → str¶

Given a sub-bin type enum, return its name as it would appear in: a residue params file.

C++: core::scoring::bin_transitions::BinTransitionData::get_subbin_type_name(const enum core::scoring::bin_transitions::BTSB_SUBBIN_TYPE) const –> std::string

has_property(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, property: pyrosetta.rosetta.core.scoring.bin_transitions.BT_PROPERTIES, rsd: pyrosetta.rosetta.core.conformation.Residue) → bool¶

Given a property, check whether a residue has that property.

This function provides the link to the suitable property lookup function in ResidueType.

C++: core::scoring::bin_transitions::BinTransitionData::has_property(const enum core::scoring::bin_transitions::BT_PROPERTIES, const class core::conformation::Residue &) const –> bool

in_bin_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin_index: int, rsd: pyrosetta.rosetta.core.conformation.Residue) → bool¶

Is a given residue within the bounds of a given bin?

Uses bin definitions for the ith residue.

C++: core::scoring::bin_transitions::BinTransitionData::in_bin_i(const unsigned long, const class core::conformation::Residue &) const –> bool

in_bin_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin_index: int, rsd: pyrosetta.rosetta.core.conformation.Residue) → bool¶

Is a given residue within the bounds of a given bin?

Uses bin definitions for the i+1st residue.

C++: core::scoring::bin_transitions::BinTransitionData::in_bin_iplus1(const unsigned long, const class core::conformation::Residue &) const –> bool

matrix_finalized(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → bool¶

Have final calculations been done after initializing the probability matrix?

C++: core::scoring::bin_transitions::BinTransitionData::matrix_finalized() const –> bool

matrix_initialized(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → bool¶

Have the n_bins_i_ and n_bins_iplus1_ variables been set, so that the: transition probability matrix could be initialized?

C++: core::scoring::bin_transitions::BinTransitionData::matrix_initialized() const –> bool

n_bins_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → int¶

Get the number of bins for the ith residue.

C++: core::scoring::bin_transitions::BinTransitionData::n_bins_i() const –> unsigned long

n_bins_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → int¶

Get the number of bins for the i+1st residue.

C++: core::scoring::bin_transitions::BinTransitionData::n_bins_iplus1() const –> unsigned long

n_mainchain_torsions_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → int¶

Get the number of mainchain torsions for the ith residue.

C++: core::scoring::bin_transitions::BinTransitionData::n_mainchain_torsions_i() const –> unsigned long

n_mainchain_torsions_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → int¶

Get the number of mainchain torsions for the i+1st residue.

C++: core::scoring::bin_transitions::BinTransitionData::n_mainchain_torsions_iplus1() const –> unsigned long

probability_matrix(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, n: int, m: int) → float¶

Get an entry in the transition probability matrix.

[n][m] = bin of ith residue, bin of i+1st residue.

C++: core::scoring::bin_transitions::BinTransitionData::probability_matrix(const unsigned long, const unsigned long) const –> double

prohibit_property_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, property: str) → None¶

Add a property to the list of properties that the ith residue MUST NOT have.

C++: core::scoring::bin_transitions::BinTransitionData::prohibit_property_i(const std::string &) –> void

prohibit_property_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, property: str) → None¶

Add a property to the list of properties that the i+1st residue MUST NOT have.

C++: core::scoring::bin_transitions::BinTransitionData::prohibit_property_iplus1(const std::string &) –> void

prohibit_res_identity_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, resname: str) → None¶

Add a residue identity to the list of residue identities that the ith residue MUST NOT have.

If the list is left empty, the residue identities can be anything. Residue names are provided as three-letter codes.

C++: core::scoring::bin_transitions::BinTransitionData::prohibit_res_identity_i(const std::string &) –> void

prohibit_res_identity_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, resname: str) → None¶

Add a residue identity to the list of residue identities that the i+1st residue MUST NOT have.

If the list is left empty, the residue identities can be anything. Residue names are provided as three-letter codes.

C++: core::scoring::bin_transitions::BinTransitionData::prohibit_res_identity_iplus1(const std::string &) –> void

random_bin_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → int¶

Select a random bin from the bins allowed for residue i, biased by the relative counts for that bin.

C++: core::scoring::bin_transitions::BinTransitionData::random_bin_i() const –> unsigned long

random_bin_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → int¶

Select a random bin from the bins allowed for residue i+1, biased by the relative counts for that bin.

C++: core::scoring::bin_transitions::BinTransitionData::random_bin_iplus1() const –> unsigned long

random_bin_iplus1_given_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin_i: int) → int¶

Select a random bin from the bins allowed for residue i+1, biased by the relative counts for that bin given that residue i is in a particular bin.

C++: core::scoring::bin_transitions::BinTransitionData::random_bin_iplus1_given_i(const unsigned long) const –> unsigned long

set_binname_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin: int, name: str) → None¶

Set the name of bin n for residue i.

This requires that the number of bins has already been set.

C++: core::scoring::bin_transitions::BinTransitionData::set_binname_i(const unsigned long, const std::string &) –> void

set_binname_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin: int, name: str) → None¶

Set the name of bin n for residue i+1.

This requires that the number of bins has already been set.

C++: core::scoring::bin_transitions::BinTransitionData::set_binname_iplus1(const unsigned long, const std::string &) –> void

set_binrange_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin: int, torsion: int, start: float, end: float) → None¶

Set the torsion ranges for bin n, mainchain torsion m of residue i.

This requires that the number of bins and the number of mainchain torsions have already been set.

C++: core::scoring::bin_transitions::BinTransitionData::set_binrange_i(const unsigned long, const unsigned long, const double &, const double &) –> void

set_binrange_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin: int, torsion: int, start: float, end: float) → None¶

Set the torsion ranges for bin n, mainchain torsion m of residue i+1.

This requires that the number of bins and the number of mainchain torsions have already been set.

C++: core::scoring::bin_transitions::BinTransitionData::set_binrange_iplus1(const unsigned long, const unsigned long, const double &, const double &) –> void

set_matrix_entry(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, n: int, m: int, val: float) → None¶

Set a value in the transition probability matrix.

C++: core::scoring::bin_transitions::BinTransitionData::set_matrix_entry(const unsigned long, const unsigned long, const double &) –> void

set_n_bins(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, n_bins_i: int, n_bins_iplus1: int) → None¶

Set the number of bins for the ith and i+1st residues.

This also initializes the probability matrix (to all zeros), the binnames vectors (to vectors of empty strings), and the binranges vectors (to all zeros).

C++: core::scoring::bin_transitions::BinTransitionData::set_n_bins(const unsigned long, const unsigned long) –> void

set_n_mainchain_torsions_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, val: int) → None¶

Set the number of mainchain torsions for residue i.

C++: core::scoring::bin_transitions::BinTransitionData::set_n_mainchain_torsions_i(const unsigned long) –> void

set_n_mainchain_torsions_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, val: int) → None¶

Set the number of mainchain torsions for residue i+1.

C++: core::scoring::bin_transitions::BinTransitionData::set_n_mainchain_torsions_iplus1(const unsigned long) –> void

set_subbin_type_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, type: str) → None¶

Set the sub-bin type for residue i.

Each bin can be divided into sub-bins in one of several ways. For example, phi/psi/omega bins (like the ABEGO bins) can be divided into 5x5x90 bins corresponding to the bins used by the Rama scorefunction. This is useful for drawing random phi/psi angles from within the bin.

C++: core::scoring::bin_transitions::BinTransitionData::set_subbin_type_i(const std::string &) –> void

set_subbin_type_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, type: str) → None¶

Set the sub-bin type for residue i+1.

Each bin can be divided into sub-bins in one of several ways. For example, phi/psi/omega bins (like the ABEGO bins) can be divided into 5x5x90 bins corresponding to the bins used by the Rama scorefunction. This is useful for drawing random phi/psi angles from within the bin.

C++: core::scoring::bin_transitions::BinTransitionData::set_subbin_type_iplus1(const std::string &) –> void

subbin_cdf_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, n: int) → pyrosetta.rosetta.utility.vector1_double¶

Get the sub-bin cumulative distribution function for bin n for the ith residue.

Const-access only.

C++: core::scoring::bin_transitions::BinTransitionData::subbin_cdf_i(const unsigned long) const –> const class utility::vector1<double, class std::allocator<double> > &

subbin_cdf_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, n: int) → pyrosetta.rosetta.utility.vector1_double¶

Get the sub-bin cumulative distribution function for bin n for the i+1st residue.

Const-access only.

C++: core::scoring::bin_transitions::BinTransitionData::subbin_cdf_iplus1(const unsigned long) const –> const class utility::vector1<double, class std::allocator<double> > &

subbin_end_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin_i: int, subbin_j: int, mainchain_torsion_k: int) → float¶

Get the end of the sub-bin torsion range for the ith bin, the jth sub-bin, and the kth mainchain torsion.

C++: core::scoring::bin_transitions::BinTransitionData::subbin_end_i(const unsigned long, const unsigned long, const unsigned long) const –> double

subbin_end_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin_i: int, subbin_j: int, mainchain_torsion_k: int) → float¶

Get the end of the sub-bin torsion range for the ith bin, the jth sub-bin, and the kth mainchain torsion.

C++: core::scoring::bin_transitions::BinTransitionData::subbin_end_iplus1(const unsigned long, const unsigned long, const unsigned long) const –> double

subbin_start_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin_i: int, subbin_j: int, mainchain_torsion_k: int) → float¶

Get the start of the sub-bin torsion range for the ith bin, the jth sub-bin, and the kth mainchain torsion.

C++: core::scoring::bin_transitions::BinTransitionData::subbin_start_i(const unsigned long, const unsigned long, const unsigned long) const –> double

subbin_start_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, bin_i: int, subbin_j: int, mainchain_torsion_k: int) → float¶

Get the start of the sub-bin torsion range for the ith bin, the jth sub-bin, and the kth mainchain torsion.

C++: core::scoring::bin_transitions::BinTransitionData::subbin_start_iplus1(const unsigned long, const unsigned long, const unsigned long) const –> double

subbin_type_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → pyrosetta.rosetta.core.scoring.bin_transitions.BTSB_SUBBIN_TYPE¶

Get the sub-bin type enum for residue i.

C++: core::scoring::bin_transitions::BinTransitionData::subbin_type_i() const –> enum core::scoring::bin_transitions::BTSB_SUBBIN_TYPE

subbin_type_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData) → pyrosetta.rosetta.core.scoring.bin_transitions.BTSB_SUBBIN_TYPE¶

Get the sub-bin type enum for residue i+1.

C++: core::scoring::bin_transitions::BinTransitionData::subbin_type_iplus1() const –> enum core::scoring::bin_transitions::BTSB_SUBBIN_TYPE

summarize_data(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, verbose: bool) → str¶

Writes a report summarizing the data stored in this BinTransitionData object.

If verbose is true, the full set of sub-bins is written out, too.

C++: core::scoring::bin_transitions::BinTransitionData::summarize_data(const bool) const –> std::string

which_bin_i(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, mainchain_torsions: pyrosetta.rosetta.utility.vector1_double) → int¶

Given a vector of mainchain torsions for a particular residue (at position i), figure out which bin the torsions lie in.

C++: core::scoring::bin_transitions::BinTransitionData::which_bin_i(const class utility::vector1<double, class std::allocator<double> > &) const –> unsigned long

which_bin_iplus1(self: pyrosetta.rosetta.core.scoring.bin_transitions.BinTransitionData, mainchain_torsions: pyrosetta.rosetta.utility.vector1_double) → int¶

Given a vector of mainchain torsions for a particular residue (at position i+1), figure out which bin the torsions lie in.

C++: core::scoring::bin_transitions::BinTransitionData::which_bin_iplus1(const class utility::vector1<double, class std::allocator<double> > &) const –> unsigned long

pyrosetta.rosetta.core.scoring.bin_transitions.deep_copy(: core::scoring::bin_transitions::BinTransitionCalculator) → core::scoring::bin_transitions::BinTransitionCalculator¶: C++: core::scoring::bin_transitions::deep_copy(const class core::scoring::bin_transitions::BinTransitionCalculator &) –> class std::shared_ptr<class core::scoring::bin_transitions::BinTransitionCalculator>