scoring¶

Bindings for core::scoring namespace

class pyrosetta.rosetta.core.scoring.APBSConfig¶

Bases: pybind11_builtins.pybind11_object

APBSConfig

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

class pyrosetta.rosetta.core.scoring.APBSResult¶

Bases: pybind11_builtins.pybind11_object

APBSResult

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

class pyrosetta.rosetta.core.scoring.APBSWrapper¶

Bases: pybind11_builtins.pybind11_object

APBS wrapper

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

exec(self: pyrosetta.rosetta.core.scoring.APBSWrapper) → core::scoring::APBSResult¶: C++: core::scoring::APBSWrapper::exec() –> class std::shared_ptr<const class core::scoring::APBSResult>

class pyrosetta.rosetta.core.scoring.AtomNeighbor¶

Bases: pybind11_builtins.pybind11_object

The neighborlist is used during minimization to speed atom-atom energy calculations. It stores a list of potentially interacting neighbor atoms for each atom in the system.

The logic for using the nblist is tricky.

Tentative scheme: turn on nblist scoring at start of minimization

// at this point, want pose to be fully scored // so perhaps a call to scorefxn(pose) ?? // Real const start_score( scorefxn( pose ) );

pose.energies().setup_use_nblist( true );

Real const start_func( func( vars ) ); // nblist setup inside this call

now require that all energy evaluations have an identical set of moving dofs (guaranteed if all energy calculations are inside function evaluations). This is checked inside each scorecaln using the nblist.

when using the nblist, the rsd-rsd neighbor information is not updated. This will probably be a good thing in that it will smooth the energy landscape during minimization…

in a nblist score calculation, we do two things: recover cached energies for non-pair-moved positions, and get atom-atom energies for the pairs that are on the nblist. We don’t cache 2d energies for moving positions, since we are not looping over rsd nbr links for that score calculation so the caching would be pretty time- consuming I think.

The nblist has the count_pair weights stored, so no calls to count_pair !!

turn off nblist scoring at the end of minimization. Since we have not been updating rsd-pair energies for moving pairs, and the rsd-rsd nblist is potentially out of data, we reset the neighborgraph at this point to ensure a complete score calculation next time.

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

atomno(self: pyrosetta.rosetta.core.scoring.AtomNeighbor) → int¶: C++: core::scoring::AtomNeighbor::atomno() const –> int

path_dist(self: pyrosetta.rosetta.core.scoring.AtomNeighbor) → int¶: C++: core::scoring::AtomNeighbor::path_dist() const –> unsigned long

rsd(self: pyrosetta.rosetta.core.scoring.AtomNeighbor) → int¶: C++: core::scoring::AtomNeighbor::rsd() const –> int

temp1(self: pyrosetta.rosetta.core.scoring.AtomNeighbor) → float¶: C++: core::scoring::AtomNeighbor::temp1() const –> double &

temp2(self: pyrosetta.rosetta.core.scoring.AtomNeighbor) → float¶: C++: core::scoring::AtomNeighbor::temp2() const –> double &

temp3(self: pyrosetta.rosetta.core.scoring.AtomNeighbor) → float¶: C++: core::scoring::AtomNeighbor::temp3() const –> double &

temp4(self: pyrosetta.rosetta.core.scoring.AtomNeighbor) → float¶: C++: core::scoring::AtomNeighbor::temp4() const –> double &

weight(self: pyrosetta.rosetta.core.scoring.AtomNeighbor) → float¶: C++: core::scoring::AtomNeighbor::weight() const –> double

weight_func(self: pyrosetta.rosetta.core.scoring.AtomNeighbor) → float¶

fpd

C++: core::scoring::AtomNeighbor::weight_func() const –> double

class pyrosetta.rosetta.core.scoring.BB_Pos¶

Bases: pybind11_builtins.pybind11_object

C(self: pyrosetta.rosetta.core.scoring.BB_Pos, i: int) → pyrosetta.rosetta.numeric.xyzVector_double_t¶

accessor for C’s coordinate on residue i, requires take_coordinates_from_pose have been recently called.

C++: core::scoring::BB_Pos::C(const int) const –> const class numeric::xyzVector<double> &

CA(self: pyrosetta.rosetta.core.scoring.BB_Pos, i: int) → pyrosetta.rosetta.numeric.xyzVector_double_t¶

accessor for CA’s coordinate on residue i, requires take_coordinates_from_pose have been recently called.

C++: core::scoring::BB_Pos::CA(const int) const –> const class numeric::xyzVector<double> &

CB(self: pyrosetta.rosetta.core.scoring.BB_Pos, i: int) → pyrosetta.rosetta.numeric.xyzVector_double_t¶

accessor for CB’s coordinate on residue i, requires take_coordinates_from_pose have been recently called.

C++: core::scoring::BB_Pos::CB(const int) const –> const class numeric::xyzVector<double> &

N(self: pyrosetta.rosetta.core.scoring.BB_Pos, i: int) → pyrosetta.rosetta.numeric.xyzVector_double_t¶

accessor for N’s coordinate on residue i, requires take_coordinates_from_pose have been recently called.

C++: core::scoring::BB_Pos::N(const int) const –> const class numeric::xyzVector<double> &

O(self: pyrosetta.rosetta.core.scoring.BB_Pos, i: int) → pyrosetta.rosetta.numeric.xyzVector_double_t¶

accessor for O’s coordinate on residue i, requires take_coordinates_from_pose have been recently called.

C++: core::scoring::BB_Pos::O(const int) const –> const class numeric::xyzVector<double> &

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

resize(self: pyrosetta.rosetta.core.scoring.BB_Pos, nres: int) → None¶: C++: core::scoring::BB_Pos::resize(const int) –> void

take_coordinates_from_pose(self: pyrosetta.rosetta.core.scoring.BB_Pos, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::BB_Pos::take_coordinates_from_pose(const class core::pose::Pose &) –> void

pyrosetta.rosetta.core.scoring.CA_gdtmm(*args, **kwargs)¶

Overloaded function.

CA_gdtmm(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, residues: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long) -> float

Compute the CA RMSD between two poses.

C++: core::scoring::CA_gdtmm(const class core::pose::Pose &, const class core::pose::Pose &, const class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &) –> double

CA_gdtmm(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) -> float

Calculate gdtmm score based on the C-alpha positions in pose1 and pose2.

C++: core::scoring::CA_gdtmm(const class core::pose::Pose &, const class core::pose::Pose &) –> double

CA_gdtmm(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, m_1_1: float, m_2_2: float, m_3_3: float, m_4_3: float, m_7_4: float) -> float

Calculate gdtmm score based on the C-alpha positions in pose1 and pose2. Also returns the: five components of the gdtmm score.

C++: core::scoring::CA_gdtmm(const class core::pose::Pose &, const class core::pose::Pose &, double &, double &, double &, double &, double &) –> double

CA_gdtmm(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, residue_selection: pyrosetta.rosetta.std.list_unsigned_long_t, m_1_1: float, m_2_2: float, m_3_3: float, m_4_3: float, m_7_4: float) -> float

C++: core::scoring::CA_gdtmm(const class core::pose::Pose &, const class core::pose::Pose &, const class std::list<unsigned long, class std::allocator<unsigned long> > &, double &, double &, double &, double &, double &) –> double

CA_gdtmm(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, residue_selection: pyrosetta.rosetta.std.list_unsigned_long_t) -> float

Calculate gdtmm score based on the C-alpha positions in pose1 and pose2.

C++: core::scoring::CA_gdtmm(const class core::pose::Pose &, const class core::pose::Pose &, const class std::list<unsigned long, class std::allocator<unsigned long> > &) –> double

pyrosetta.rosetta.core.scoring.CA_gdttm(*args, **kwargs)¶

Overloaded function.

CA_gdttm(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, gdttm_score: float, gdtha_score: float, residue_selection: pyrosetta.rosetta.std.list_unsigned_long_t) -> None

Calculate gdttm score based on the C-alpha positions in pose1 and pose2.

C++: core::scoring::CA_gdttm(const class core::pose::Pose &, const class core::pose::Pose &, double &, double &, const class std::list<unsigned long, class std::allocator<unsigned long> > &) –> void

CA_gdttm(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, gdttm_score: float, gdtha_score: float, residues: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long) -> None

C++: core::scoring::CA_gdttm(const class core::pose::Pose &, const class core::pose::Pose &, double &, double &, const class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &) –> void

CA_gdttm(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, gdttm_score: float, gdtha_score: float) -> None

C++: core::scoring::CA_gdttm(const class core::pose::Pose &, const class core::pose::Pose &, double &, double &) –> void

pyrosetta.rosetta.core.scoring.CA_maxsub(*args, **kwargs)¶

Overloaded function.

CA_maxsub(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) -> int
CA_maxsub(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, rms: float) -> int

Calculates a C-alpha maxsub-based superposition between pose1 and pose2, returns: the number of residues superimposed past a certain threshold. See maxsub.hh and maxsub.cc for more information.

C++: core::scoring::CA_maxsub(const class core::pose::Pose &, const class core::pose::Pose &, double) –> int

CA_maxsub(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, residue_selection: pyrosetta.rosetta.std.list_unsigned_long_t) -> int
CA_maxsub(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, residue_selection: pyrosetta.rosetta.std.list_unsigned_long_t, rms: float) -> int

C++: core::scoring::CA_maxsub(const class core::pose::Pose &, const class core::pose::Pose &, class std::list<unsigned long, class std::allocator<unsigned long> >, double) –> int

pyrosetta.rosetta.core.scoring.CA_or_equiv_rmsd(*args, **kwargs)¶

Overloaded function.

CA_or_equiv_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) -> float
CA_or_equiv_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, start: int) -> float
CA_or_equiv_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, start: int, end: int) -> float

Compute rmsd for residues between start and end.: If start and end aren’t specified, use the entire pose.

C++: core::scoring::CA_or_equiv_rmsd(const class core::pose::Pose &, const class core::pose::Pose &, unsigned long, unsigned long) –> double

pyrosetta.rosetta.core.scoring.CA_rmsd(*args, **kwargs)¶

Overloaded function.

CA_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, residues: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long) -> float

Compute the CA RMSD between two poses.

C++: core::scoring::CA_rmsd(const class core::pose::Pose &, const class core::pose::Pose &, const class std::map<unsigned long, unsigned long, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, unsigned long> > > &) –> double

CA_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) -> float
CA_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, start: int) -> float
CA_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, start: int, end: int) -> float

Compute rmsd for residues between start and end.: If start and end aren’t specified, use the entire pose.

C++: core::scoring::CA_rmsd(const class core::pose::Pose &, const class core::pose::Pose &, unsigned long, unsigned long) –> double

CA_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, start: int, end: int, exclude: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

C++: core::scoring::CA_rmsd(const class core::pose::Pose &, const class core::pose::Pose &, unsigned long, unsigned long, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> double

CA_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, residue_selection: pyrosetta.rosetta.std.list_unsigned_long_t) -> float

C++: core::scoring::CA_rmsd(const class core::pose::Pose &, const class core::pose::Pose &, class std::list<unsigned long, class std::allocator<unsigned long> >) –> double

pyrosetta.rosetta.core.scoring.CA_rmsd_symmetric(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) → float¶: C++: core::scoring::CA_rmsd_symmetric(const class core::pose::Pose &, const class core::pose::Pose &) –> double

class pyrosetta.rosetta.core.scoring.CSA¶

Bases: pybind11_builtins.pybind11_object

CSAcomputed(self: pyrosetta.rosetta.core.scoring.CSA) → float¶: C++: core::scoring::CSA::CSAcomputed() –> double &

CSAerr(self: pyrosetta.rosetta.core.scoring.CSA) → float¶: C++: core::scoring::CSA::CSAerr() const –> double

CSAval(self: pyrosetta.rosetta.core.scoring.CSA) → float¶: C++: core::scoring::CSA::CSAval() const –> double

alpha(self: pyrosetta.rosetta.core.scoring.CSA) → float¶: C++: core::scoring::CSA::alpha() const –> double

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

atom1(self: pyrosetta.rosetta.core.scoring.CSA) → str¶: C++: core::scoring::CSA::atom1() const –> const std::string &

atom2(self: pyrosetta.rosetta.core.scoring.CSA) → str¶: C++: core::scoring::CSA::atom2() const –> const std::string &

atom3(self: pyrosetta.rosetta.core.scoring.CSA) → str¶: C++: core::scoring::CSA::atom3() const –> const std::string &

beta(self: pyrosetta.rosetta.core.scoring.CSA) → float¶: C++: core::scoring::CSA::beta() const –> double

f1ij(self: pyrosetta.rosetta.core.scoring.CSA) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: core::scoring::CSA::f1ij() const –> class numeric::xyzVector<double>

f2ij(self: pyrosetta.rosetta.core.scoring.CSA) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: core::scoring::CSA::f2ij() const –> class numeric::xyzVector<double>

f3ij(self: pyrosetta.rosetta.core.scoring.CSA) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: core::scoring::CSA::f3ij() const –> class numeric::xyzVector<double>

gamma(self: pyrosetta.rosetta.core.scoring.CSA) → float¶: C++: core::scoring::CSA::gamma() const –> double

res1(self: pyrosetta.rosetta.core.scoring.CSA) → int¶: C++: core::scoring::CSA::res1() const –> unsigned long

res2(self: pyrosetta.rosetta.core.scoring.CSA) → int¶: C++: core::scoring::CSA::res2() const –> unsigned long

res3(self: pyrosetta.rosetta.core.scoring.CSA) → int¶: C++: core::scoring::CSA::res3() const –> unsigned long

set_weight(self: pyrosetta.rosetta.core.scoring.CSA, w_in: float) → None¶: C++: core::scoring::CSA::set_weight(double) –> void

show(self: pyrosetta.rosetta.core.scoring.CSA, : pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::CSA::show(class std::basic_ostream<char> &) const –> void

sigma1(self: pyrosetta.rosetta.core.scoring.CSA) → float¶: C++: core::scoring::CSA::sigma1() const –> double

sigma2(self: pyrosetta.rosetta.core.scoring.CSA) → float¶: C++: core::scoring::CSA::sigma2() const –> double

sigma3(self: pyrosetta.rosetta.core.scoring.CSA) → float¶: C++: core::scoring::CSA::sigma3() const –> double

weight(self: pyrosetta.rosetta.core.scoring.CSA) → float¶: C++: core::scoring::CSA::weight() const –> double

class pyrosetta.rosetta.core.scoring.CenListInfo¶

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

Keep track of the cenlist information

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

calculated(self: pyrosetta.rosetta.core.scoring.CenListInfo) → bool¶: C++: core::scoring::CenListInfo::calculated() –> bool &

clone(self: pyrosetta.rosetta.core.scoring.CenListInfo) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: core::scoring::CenListInfo::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

fcen10(self: pyrosetta.rosetta.core.scoring.CenListInfo, seqpos: int) → float¶: C++: core::scoring::CenListInfo::fcen10(const unsigned long) –> double &

fcen12(self: pyrosetta.rosetta.core.scoring.CenListInfo, seqpos: int) → float¶: C++: core::scoring::CenListInfo::fcen12(const unsigned long) –> double &

fcen6(self: pyrosetta.rosetta.core.scoring.CenListInfo, seqpos: int) → float¶: C++: core::scoring::CenListInfo::fcen6(const unsigned long) –> double &

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t¶: C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

initialize(self: pyrosetta.rosetta.core.scoring.CenListInfo, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::CenListInfo::initialize(const class core::pose::Pose &) –> void

set_fcen10(self: pyrosetta.rosetta.core.scoring.CenListInfo, seqpos: int, value: float) → None¶: C++: core::scoring::CenListInfo::set_fcen10(const unsigned long, double) –> void

set_fcen12(self: pyrosetta.rosetta.core.scoring.CenListInfo, seqpos: int, value: float) → None¶: C++: core::scoring::CenListInfo::set_fcen12(const unsigned long, double) –> void

set_fcen6(self: pyrosetta.rosetta.core.scoring.CenListInfo, seqpos: int, value: float) → None¶: C++: core::scoring::CenListInfo::set_fcen6(const unsigned long, double) –> void

size(self: pyrosetta.rosetta.core.scoring.CenListInfo) → int¶: C++: core::scoring::CenListInfo::size() const –> unsigned long

class pyrosetta.rosetta.core.scoring.ChemicalShiftAnisotropy¶

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

ChemicalShiftAnisotropys are mainly handled by this class

related classed: CSA — a single line in an CSA file - representing a single csa coupling: ChemicalShiftAnisotropyEnergy – an energy method which triggers computations handled by this class.

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

clone(self: pyrosetta.rosetta.core.scoring.ChemicalShiftAnisotropy) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: core::scoring::ChemicalShiftAnisotropy::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

compute_csascore(self: pyrosetta.rosetta.core.scoring.ChemicalShiftAnisotropy, pose: pyrosetta.rosetta.core.pose.Pose) → float¶

compute csa score for given pose (non-constant due to membrane)

C++: core::scoring::ChemicalShiftAnisotropy::compute_csascore(class core::pose::Pose &) –> double

get_CSA_data(self: pyrosetta.rosetta.core.scoring.ChemicalShiftAnisotropy) → pyrosetta.rosetta.utility.vector1_core_scoring_CSA¶

get the raw CSA data

C++: core::scoring::ChemicalShiftAnisotropy::get_CSA_data() const –> const class utility::vector1<class core::scoring::CSA, class std::allocator<class core::scoring::CSA> > &

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t¶: C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

show(self: pyrosetta.rosetta.core.scoring.ChemicalShiftAnisotropy, : pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::ChemicalShiftAnisotropy::show(class std::basic_ostream<char> &) const –> void

class pyrosetta.rosetta.core.scoring.ContextGraphType¶

Bases: pybind11_builtins.pybind11_object

Members:

ten_A_neighbor_graph

twelve_A_neighbor_graph

centroid_neighbor_graph

num_context_graph_types

class pyrosetta.rosetta.core.scoring.DC¶

Bases: pybind11_builtins.pybind11_object

class DC_TYPE¶

Bases: pybind11_builtins.pybind11_object

Members:

DC_TYPE_NH

DC_TYPE_NC

DC_TYPE_CH

DC_TYPE_CC

DCcomputed(self: pyrosetta.rosetta.core.scoring.DC) → float¶: C++: core::scoring::DC::DCcomputed() –> double &

DCerr(self: pyrosetta.rosetta.core.scoring.DC) → float¶: C++: core::scoring::DC::DCerr() const –> double

DCval(self: pyrosetta.rosetta.core.scoring.DC) → float¶: C++: core::scoring::DC::DCval() const –> double

Dconst(self: pyrosetta.rosetta.core.scoring.DC) → float¶: C++: core::scoring::DC::Dconst() const –> double

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

atom1(self: pyrosetta.rosetta.core.scoring.DC) → str¶: C++: core::scoring::DC::atom1() const –> const std::string &

atom2(self: pyrosetta.rosetta.core.scoring.DC) → str¶: C++: core::scoring::DC::atom2() const –> const std::string &

f1ij(self: pyrosetta.rosetta.core.scoring.DC) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: core::scoring::DC::f1ij() const –> class numeric::xyzVector<double>

f2ij(self: pyrosetta.rosetta.core.scoring.DC) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: core::scoring::DC::f2ij() const –> class numeric::xyzVector<double>

get_DC_data_type(self: pyrosetta.rosetta.core.scoring.DC, atom1: str, atom2: str) → pyrosetta.rosetta.core.scoring.DC.DC_TYPE¶: C++: core::scoring::DC::get_DC_data_type(const class std::basic_string<char> &, const class std::basic_string<char> &) –> enum core::scoring::DC::DC_TYPE

res1(self: pyrosetta.rosetta.core.scoring.DC) → int¶: C++: core::scoring::DC::res1() const –> unsigned long

res2(self: pyrosetta.rosetta.core.scoring.DC) → int¶: C++: core::scoring::DC::res2() const –> unsigned long

set_weight(self: pyrosetta.rosetta.core.scoring.DC, w_in: float) → None¶: C++: core::scoring::DC::set_weight(double) –> void

show(self: pyrosetta.rosetta.core.scoring.DC, : pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::DC::show(class std::basic_ostream<char> &) const –> void

type(self: pyrosetta.rosetta.core.scoring.DC) → pyrosetta.rosetta.core.scoring.DC.DC_TYPE¶: C++: core::scoring::DC::type() const –> enum core::scoring::DC::DC_TYPE

weight(self: pyrosetta.rosetta.core.scoring.DC) → float¶: C++: core::scoring::DC::weight() const –> double

class pyrosetta.rosetta.core.scoring.DenseEnergyContainer¶

Bases: pyrosetta.rosetta.core.scoring.LREnergyContainer

any_neighbors_for_residue(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer, : int) → bool¶: C++: core::scoring::DenseEnergyContainer::any_neighbors_for_residue(int) const –> bool

any_upper_neighbors_for_residue(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer, resid: int) → bool¶: C++: core::scoring::DenseEnergyContainer::any_upper_neighbors_for_residue(int) const –> bool

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

clone(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer) → pyrosetta.rosetta.core.scoring.LREnergyContainer¶: C++: core::scoring::DenseEnergyContainer::clone() const –> class std::shared_ptr<class core::scoring::LREnergyContainer>

const_neighbor_iterator_begin(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator¶

///////////////// const versions

C++: core::scoring::DenseEnergyContainer::const_neighbor_iterator_begin(int) const –> class std::shared_ptr<class core::scoring::ResidueNeighborConstIterator>

const_neighbor_iterator_end(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator¶: C++: core::scoring::DenseEnergyContainer::const_neighbor_iterator_end(int) const –> class std::shared_ptr<class core::scoring::ResidueNeighborConstIterator>

const_upper_neighbor_iterator_begin(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator¶: C++: core::scoring::DenseEnergyContainer::const_upper_neighbor_iterator_begin(int) const –> class std::shared_ptr<class core::scoring::ResidueNeighborConstIterator>

const_upper_neighbor_iterator_end(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator¶: C++: core::scoring::DenseEnergyContainer::const_upper_neighbor_iterator_end(int) const –> class std::shared_ptr<class core::scoring::ResidueNeighborConstIterator>

empty(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer) → bool¶: C++: core::scoring::DenseEnergyContainer::empty() const –> bool

neighbor_iterator_begin(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator¶

///////////////// non-const versions

C++: core::scoring::DenseEnergyContainer::neighbor_iterator_begin(int) –> class std::shared_ptr<class core::scoring::ResidueNeighborIterator>

neighbor_iterator_end(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator¶: C++: core::scoring::DenseEnergyContainer::neighbor_iterator_end(int) –> class std::shared_ptr<class core::scoring::ResidueNeighborIterator>

set_num_nodes(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer, size_in: int) → None¶: C++: core::scoring::DenseEnergyContainer::set_num_nodes(unsigned long) –> void

size(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer) → int¶: C++: core::scoring::DenseEnergyContainer::size() const –> unsigned long

upper_neighbor_iterator_begin(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator¶: C++: core::scoring::DenseEnergyContainer::upper_neighbor_iterator_begin(int) –> class std::shared_ptr<class core::scoring::ResidueNeighborIterator>

upper_neighbor_iterator_end(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator¶: C++: core::scoring::DenseEnergyContainer::upper_neighbor_iterator_end(int) –> class std::shared_ptr<class core::scoring::ResidueNeighborIterator>

class pyrosetta.rosetta.core.scoring.DenseNeighborConstIterator¶

Bases: pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

accumulate_energy(self: pyrosetta.rosetta.core.scoring.DenseNeighborConstIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None¶: C++: core::scoring::DenseNeighborConstIterator::accumulate_energy(class core::scoring::EMapVector &) const –> void

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

energy_computed(self: pyrosetta.rosetta.core.scoring.DenseNeighborConstIterator) → bool¶: C++: core::scoring::DenseNeighborConstIterator::energy_computed() const –> bool

lower_neighbor_id(self: pyrosetta.rosetta.core.scoring.DenseNeighborConstIterator) → int¶: C++: core::scoring::DenseNeighborConstIterator::lower_neighbor_id() const –> unsigned long

neighbor_id(self: pyrosetta.rosetta.core.scoring.DenseNeighborConstIterator) → int¶: C++: core::scoring::DenseNeighborConstIterator::neighbor_id() const –> unsigned long

plus_plus(self: pyrosetta.rosetta.core.scoring.DenseNeighborConstIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator¶: C++: core::scoring::DenseNeighborConstIterator::operator++() –> const class core::scoring::ResidueNeighborConstIterator &

residue_iterated_on(self: pyrosetta.rosetta.core.scoring.DenseNeighborConstIterator) → int¶: C++: core::scoring::DenseNeighborConstIterator::residue_iterated_on() const –> unsigned long

retrieve_energy(self: pyrosetta.rosetta.core.scoring.DenseNeighborConstIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None¶: C++: core::scoring::DenseNeighborConstIterator::retrieve_energy(class core::scoring::EMapVector &) const –> void

upper_neighbor_id(self: pyrosetta.rosetta.core.scoring.DenseNeighborConstIterator) → int¶: C++: core::scoring::DenseNeighborConstIterator::upper_neighbor_id() const –> unsigned long

class pyrosetta.rosetta.core.scoring.DenseNeighborIterator¶

Bases: pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

accumulate_energy(self: pyrosetta.rosetta.core.scoring.DenseNeighborIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None¶: C++: core::scoring::DenseNeighborIterator::accumulate_energy(class core::scoring::EMapVector &) const –> void

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

energy_computed(self: pyrosetta.rosetta.core.scoring.DenseNeighborIterator) → bool¶: C++: core::scoring::DenseNeighborIterator::energy_computed() const –> bool

lower_neighbor_id(self: pyrosetta.rosetta.core.scoring.DenseNeighborIterator) → int¶: C++: core::scoring::DenseNeighborIterator::lower_neighbor_id() const –> unsigned long

mark_energy_computed(self: pyrosetta.rosetta.core.scoring.DenseNeighborIterator) → None¶: C++: core::scoring::DenseNeighborIterator::mark_energy_computed() –> void

mark_energy_uncomputed(self: pyrosetta.rosetta.core.scoring.DenseNeighborIterator) → None¶: C++: core::scoring::DenseNeighborIterator::mark_energy_uncomputed() –> void

neighbor_id(self: pyrosetta.rosetta.core.scoring.DenseNeighborIterator) → int¶: C++: core::scoring::DenseNeighborIterator::neighbor_id() const –> unsigned long

plus_plus(self: pyrosetta.rosetta.core.scoring.DenseNeighborIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator¶: C++: core::scoring::DenseNeighborIterator::operator++() –> const class core::scoring::ResidueNeighborIterator &

residue_iterated_on(self: pyrosetta.rosetta.core.scoring.DenseNeighborIterator) → int¶: C++: core::scoring::DenseNeighborIterator::residue_iterated_on() const –> unsigned long

retrieve_energy(self: pyrosetta.rosetta.core.scoring.DenseNeighborIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None¶: C++: core::scoring::DenseNeighborIterator::retrieve_energy(class core::scoring::EMapVector &) const –> void

save_energy(self: pyrosetta.rosetta.core.scoring.DenseNeighborIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None¶: C++: core::scoring::DenseNeighborIterator::save_energy(const class core::scoring::EMapVector &) –> void

upper_neighbor_id(self: pyrosetta.rosetta.core.scoring.DenseNeighborIterator) → int¶: C++: core::scoring::DenseNeighborIterator::upper_neighbor_id() const –> unsigned long

class pyrosetta.rosetta.core.scoring.DerivVectorPair¶

Bases: pybind11_builtins.pybind11_object

A glorified struct for holding f1/f2 vectors used to represent the derivatives in our internal-geometry based minimization algorithms.

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

f1(self: pyrosetta.rosetta.core.scoring.DerivVectorPair) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: core::scoring::DerivVectorPair::f1() –> class numeric::xyzVector<double> &

f2(self: pyrosetta.rosetta.core.scoring.DerivVectorPair) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: core::scoring::DerivVectorPair::f2() –> class numeric::xyzVector<double> &

class pyrosetta.rosetta.core.scoring.DipolarCoupling¶

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

DipolarCouplings are mainly handled by this class

related classed: DC — a single line in an DC file - representing a single dc coupling: DipolarCouplingEnergy – an energy method which triggers computations handled by this class.

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

clone(self: pyrosetta.rosetta.core.scoring.DipolarCoupling) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: core::scoring::DipolarCoupling::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

compute_dcscore(self: pyrosetta.rosetta.core.scoring.DipolarCoupling, pose: pyrosetta.rosetta.core.pose.Pose) → float¶

compute dc score for given pose (non-constant due to membrane)

C++: core::scoring::DipolarCoupling::compute_dcscore(class core::pose::Pose &) –> double

get_DC_data(self: pyrosetta.rosetta.core.scoring.DipolarCoupling) → pyrosetta.rosetta.utility.vector1_core_scoring_DC¶

get the raw DC data

C++: core::scoring::DipolarCoupling::get_DC_data() const –> const class utility::vector1<class core::scoring::DC, class std::allocator<class core::scoring::DC> > &

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t¶: C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

show(self: pyrosetta.rosetta.core.scoring.DipolarCoupling, : pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::DipolarCoupling::show(class std::basic_ostream<char> &) const –> void

class pyrosetta.rosetta.core.scoring.EMapVector¶

Bases: pybind11_builtins.pybind11_object

A vector for storing energy data, initially all values are 0

: several methods using EMapVector objects add in values,

be sure to use the zero method between uses

Common Methods:: EMapVector.zero

accumulate(*args, **kwargs)¶

Overloaded function.

accumulate(self: pyrosetta.rosetta.core.scoring.EMapVector, src: pyrosetta.rosetta.core.scoring.EMapVector, l: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType) -> None

accumulate a subset of the positions

C++: core::scoring::EMapVector::accumulate(const class core::scoring::EMapVector &, const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &) –> void

accumulate(self: pyrosetta.rosetta.core.scoring.EMapVector, src: pyrosetta.rosetta.core.scoring.EMapVector, l: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType, wt: float) -> None

accumulate a subset of the positions with a common weight factor

C++: core::scoring::EMapVector::accumulate(const class core::scoring::EMapVector &, const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &, const double) –> void

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

begin(self: pyrosetta.rosetta.core.scoring.EMapVector) → float¶

non-const-iterator to the begining of the vector of energies

C++: core::scoring::EMapVector::begin() –> double *

clear(self: pyrosetta.rosetta.core.scoring.EMapVector) → None¶

Set every value to zero

example(s):

emap.zero()

See also:

EMapVector EMapVector.get EMapVector.set ScoreFunction create_score_function

C++: core::scoring::EMapVector::clear() –> void

dot(*args, **kwargs)¶

Overloaded function.

dot(self: pyrosetta.rosetta.core.scoring.EMapVector, src: pyrosetta.rosetta.core.scoring.EMapVector) -> float

Returns the dot product of this object with EMapVector <src>

: useful for multiplying weights with scores

example(s):

we = scorefxn.weights() emap.dot(we)

See also:

EMapVector ScoreFunction ScoreFunction.weights create_score_function

C++: core::scoring::EMapVector::dot(const class core::scoring::EMapVector &) const –> double

dot(self: pyrosetta.rosetta.core.scoring.EMapVector, src: pyrosetta.rosetta.core.scoring.EMapVector, l: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType) -> float

dot product of two EMapVectors: over a subset of the score types

C++: core::scoring::EMapVector::dot(const class core::scoring::EMapVector &, const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &) const –> double

end(self: pyrosetta.rosetta.core.scoring.EMapVector) → float¶

non-const-iterator to the end of the vector of energies

C++: core::scoring::EMapVector::end() –> double *

get(self: pyrosetta.rosetta.core.scoring.EMapVector, st: pyrosetta.rosetta.core.scoring.ScoreType) → float¶

Returns the value for ScoreType <st>

example(s):

emap.get(fa_sol)

See also:

EMapVector EMapVector.set ScoreFunction create_score_function

C++: core::scoring::EMapVector::get(enum core::scoring::ScoreType) –> double

norm_squared(self: pyrosetta.rosetta.core.scoring.EMapVector, l: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType) → float¶

accumulate the squared values of a subset of the positions

C++: core::scoring::EMapVector::norm_squared(const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &) –> double

print(self: pyrosetta.rosetta.core.scoring.EMapVector) → None¶

print the contents of an emap vector to standard out

C++: core::scoring::EMapVector::print() const –> void

set(self: pyrosetta.rosetta.core.scoring.EMapVector, st: pyrosetta.rosetta.core.scoring.ScoreType, val: float) → float¶

Sets the value for ScoreType <st> to <val>

example(s):

emap.set(fa_sol,13.37)

See also:

EMapVector EMapVector.get ScoreFunction create_score_function

C++: core::scoring::EMapVector::set(enum core::scoring::ScoreType, double) –> double

show_if_nonzero_weight(self: pyrosetta.rosetta.core.scoring.EMapVector, out: pyrosetta.rosetta.std.ostream, weights: pyrosetta.rosetta.core.scoring.EMapVector) → None¶

write the energies in this energy map to the output stream for those: score types that have non-zero values in the “weights” energy map.

C++: core::scoring::EMapVector::show_if_nonzero_weight(class std::basic_ostream<char> &, const class core::scoring::EMapVector &) const –> void

show_nonzero(*args, **kwargs)¶

Overloaded function.

show_nonzero(self: pyrosetta.rosetta.core.scoring.EMapVector, out: pyrosetta.rosetta.std.ostream) -> None

Prints the non-zero positions of the energy map

Set every value to zero

example(s):

emap.show_nonzero()

See also:

EMapVector EMapVector.get ScoreFunction create_score_function

C++: core::scoring::EMapVector::show_nonzero(class std::basic_ostream<char> &) const –> void

show_nonzero(self: pyrosetta.rosetta.core.scoring.EMapVector) -> str

convert the non-zero positions of the energy map to a string

C++: core::scoring::EMapVector::show_nonzero() const –> std::string

show_weighted(self: pyrosetta.rosetta.core.scoring.EMapVector, out: pyrosetta.rosetta.std.ostream, weights: pyrosetta.rosetta.core.scoring.EMapVector) → None¶

write the weighted energies in this energy map to the output stream for those: score types that have non-zero values in the “weights” energy map.

C++: core::scoring::EMapVector::show_weighted(class std::basic_ostream<char> &, const class core::scoring::EMapVector &) const –> void

sum(self: pyrosetta.rosetta.core.scoring.EMapVector) → float¶

Returns the sum of this vector

example(s):

emap.sum()

See also:

EMapVector EMapVector.get EMapVector.set ScoreFunction create_score_function

C++: core::scoring::EMapVector::sum() –> double

weighted_string_of(self: pyrosetta.rosetta.core.scoring.EMapVector, weights: pyrosetta.rosetta.core.scoring.EMapVector) → str¶

convert the weighted energies in this energy map to a string: for those score types that have non-zero values in the “weights” energy map.

C++: core::scoring::EMapVector::weighted_string_of(const class core::scoring::EMapVector &) const –> std::string

zero(*args, **kwargs)¶

Overloaded function.

zero(self: pyrosetta.rosetta.core.scoring.EMapVector, l: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType) -> None

Zero a subset of the positions, as in calibrating a scale

C++: core::scoring::EMapVector::zero(const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &) –> void

zero(self: pyrosetta.rosetta.core.scoring.EMapVector) -> None

Set every value to zero

example(s):

emap.zero()

See also:

EMapVector EMapVector.get EMapVector.set ScoreFunction create_score_function

C++: core::scoring::EMapVector::zero() –> void

class pyrosetta.rosetta.core.scoring.Energies¶

Bases: pybind11_builtins.pybind11_object

Stores total, residue, and residue-pair energies, as well as residue neighbor information.

Meant to replace fullatom_energies:: namespace.

Stores residue neighbor information as well as cached residue

pair energies in O(N) space using a graph.

Also stores a DomainMap object which is used during scoring

to know which rsd pairs have changed relative orientation and which residues have changed internally

We distinguish between two kinds of per-residue (1D) energy:

onebody residue energies and twobody residue energies. Onebody residue energies are things like dunbrack, intrares, Paa, which depend only on the state of the residue in question. Twobody residue energies (like the residue atr energy) are summations of twobody interactions involving a single residue. The onebody energies can be reused at positions whose internal phi/psi/chi conformation hasn’t changed. Twobody residue energies, on the other hand must be invalidated if the structure has changed at all.

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

clear(self: pyrosetta.rosetta.core.scoring.Energies) → None¶

kill everything (that nobody forgot about)

C++: core::scoring::Energies::clear() –> void

clear_energies(self: pyrosetta.rosetta.core.scoring.Energies) → None¶

for debugging – forget all stored energies, does not change size

C++: core::scoring::Energies::clear_energies() –> void

clone(self: pyrosetta.rosetta.core.scoring.Energies) → pyrosetta.rosetta.core.scoring.Energies¶: C++: core::scoring::Energies::clone() const –> class std::shared_ptr<class core::scoring::Energies>

context_graph(self: pyrosetta.rosetta.core.scoring.Energies, type: pyrosetta.rosetta.core.scoring.ContextGraphType) → pyrosetta.rosetta.core.scoring.ContextGraph¶: C++: core::scoring::Energies::context_graph(enum core::scoring::ContextGraphType) –> class std::shared_ptr<class core::scoring::ContextGraph>

data(self: pyrosetta.rosetta.core.scoring.Energies) → pyrosetta.rosetta.basic.datacache.BasicDataCache¶

BasicDataCache indexed by enum in core/scoring/EnergiesCacheableDataType.hh

C++: core::scoring::Energies::data() –> class basic::datacache::BasicDataCache &

discard_conformation_domain_map(self: pyrosetta.rosetta.core.scoring.Energies) → bool¶

instructs Pose whether the domain map info in the Conformation object should be discarded

C++: core::scoring::Energies::discard_conformation_domain_map() const –> bool

domain_map(*args, **kwargs)¶

Overloaded function.

domain_map(self: pyrosetta.rosetta.core.scoring.Energies, pos: int) -> int

Return the color assigned to a particular residue (index = pos) as held in the

domain map describing how this residue has moved with respect to the other residues in the pose.

CAUTION new behavior: domain_map may not return 0 for residues that have undergone internal degree of freedom changes since the last scoring. Ask the res_moved() method for that information

C++: core::scoring::Energies::domain_map(const int) const –> int

domain_map(self: pyrosetta.rosetta.core.scoring.Energies) -> ObjexxFCL::FArray1D<int>

Read access for the domain map.

C++: core::scoring::Energies::domain_map() const –> const class ObjexxFCL::FArray1D<int> &

energies_updated(self: pyrosetta.rosetta.core.scoring.Energies) → bool¶

Returns true if the score is up-to-date

example(s):

pose.energies().energies_updated()

See also:

Energies Energies.residue_total_energy Energies.residue_total_energies Pose ScoreFunction ScoreFunction.show create_score_function

C++: core::scoring::Energies::energies_updated() const –> bool

energy_graph(self: pyrosetta.rosetta.core.scoring.Energies) → core::scoring::EnergyGraph¶

Write access to the EnergyGraph.

C++: core::scoring::Energies::energy_graph() –> class core::scoring::EnergyGraph &

finalized_energies(self: pyrosetta.rosetta.core.scoring.Energies) → pyrosetta.rosetta.core.scoring.EMapVector¶

Write access to the components of the “finalized” energies.: This access is intended only for the ScoreFunction.

C++: core::scoring::Energies::finalized_energies() –> class core::scoring::EMapVector &

get_scorefxn_info(self: pyrosetta.rosetta.core.scoring.Energies) → core::scoring::ScoreFunctionInfo¶

get scorefxn info

C++: core::scoring::Energies::get_scorefxn_info() const –> const class core::scoring::ScoreFunctionInfo &

long_range_container(self: pyrosetta.rosetta.core.scoring.Energies, : pyrosetta.rosetta.core.scoring.methods.LongRangeEnergyType) → core::scoring::LREnergyContainer¶: C++: core::scoring::Energies::long_range_container(enum core::scoring::methods::LongRangeEnergyType) const –> class std::shared_ptr<const class core::scoring::LREnergyContainer>

minimization_graph(self: pyrosetta.rosetta.core.scoring.Energies) → core::scoring::MinimizationGraph¶: C++: core::scoring::Energies::minimization_graph() –> class std::shared_ptr<class core::scoring::MinimizationGraph>

nblist(self: pyrosetta.rosetta.core.scoring.Energies, type: pyrosetta.rosetta.core.scoring.EnergiesCacheableDataType.Enum) → core::scoring::NeighborList¶: C++: core::scoring::Energies::nblist(const enum core::scoring::EnergiesCacheableDataType::Enum &) const –> const class core::scoring::NeighborList &

nonconst_long_range_container(self: pyrosetta.rosetta.core.scoring.Energies, : pyrosetta.rosetta.core.scoring.methods.LongRangeEnergyType) → core::scoring::LREnergyContainer¶: C++: core::scoring::Energies::nonconst_long_range_container(enum core::scoring::methods::LongRangeEnergyType) –> class std::shared_ptr<class core::scoring::LREnergyContainer>

onebody_energies(self: pyrosetta.rosetta.core.scoring.Energies, seqpos: int) → pyrosetta.rosetta.core.scoring.EMapVector¶

Write access to the components of the one-body energies.: This access is intended only for the ScoreFunction.

C++: core::scoring::Energies::onebody_energies(const int) –> class core::scoring::EMapVector &

require_context_graph(self: pyrosetta.rosetta.core.scoring.Energies, : pyrosetta.rosetta.core.scoring.ContextGraphType) → None¶

Allows non-scorefunction components of Rosetta to impose requirements on: the context graphs that this object maintains.

C++: core::scoring::Energies::require_context_graph(enum core::scoring::ContextGraphType) const –> void

res_moved(self: pyrosetta.rosetta.core.scoring.Energies, seqpos: int) → bool¶

check if rsd has changed internal conformation, necessitating, recomputation of 1d energies like dun,intra,prob,etc

C++: core::scoring::Energies::res_moved(const int) const –> bool

reset_nblist(self: pyrosetta.rosetta.core.scoring.Energies) → None¶: C++: core::scoring::Energies::reset_nblist() –> void

reset_res_moved(self: pyrosetta.rosetta.core.scoring.Energies, seqpos: int) → None¶: C++: core::scoring::Energies::reset_res_moved(const int) –> void

residue_neighbors_updated(self: pyrosetta.rosetta.core.scoring.Energies) → bool¶: C++: core::scoring::Energies::residue_neighbors_updated() const –> bool

residue_total_energies(self: pyrosetta.rosetta.core.scoring.Energies, seqpos: int) → pyrosetta.rosetta.core.scoring.EMapVector¶

Returns the unweighted total_energies EnergyMap for

Residue <seqpos>

: only evaluated when requested (lazy!), inaccessible during

minimization, EnergyMap is an EMapVector

example(s):: r3 = pose.energies().residue_total_energies(3) r3[fa_sol]
See also:: Energies Energies.residue_total_energy Pose ScoreFunction ScoreFunction.show create_score_function EMapVector

C++: core::scoring::Energies::residue_total_energies(const int) const –> const class core::scoring::EMapVector &

residue_total_energy(self: pyrosetta.rosetta.core.scoring.Energies, seqpos: int) → float¶

Returns the weighted total energy of residue <seqpos>

example(s):

pose.energies().residue_total_energy(3)

See also:

Energies Energies.residue_total_energies Pose ScoreFunction ScoreFunction.show create_score_function

C++: core::scoring::Energies::residue_total_energy(const int) const –> double

same_type_as_me(*args, **kwargs)¶

Overloaded function.

same_type_as_me(self: pyrosetta.rosetta.core.scoring.Energies, other: pyrosetta.rosetta.core.scoring.Energies) -> bool
same_type_as_me(self: pyrosetta.rosetta.core.scoring.Energies, other: pyrosetta.rosetta.core.scoring.Energies, recurse: bool) -> bool

determine whether my type is the same as another Conformation’s

C++: core::scoring::Energies::same_type_as_me(const class core::scoring::Energies &, bool) const –> bool

scoring(self: pyrosetta.rosetta.core.scoring.Energies) → bool¶

are we in the midst of a scoring calculation?

C++: core::scoring::Energies::scoring() const –> bool

scoring_begin(self: pyrosetta.rosetta.core.scoring.Energies, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Notification of the start of a scoring calculation.

C++: core::scoring::Energies::scoring_begin(const class core::scoring::ScoreFunction &, const class core::pose::Pose &) –> void

scoring_end(self: pyrosetta.rosetta.core.scoring.Energies, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

signal from the scorefxn that scoring is over

C++: core::scoring::Energies::scoring_end(const class core::scoring::ScoreFunction &) –> void

set_long_range_container(self: pyrosetta.rosetta.core.scoring.Energies, : pyrosetta.rosetta.core.scoring.methods.LongRangeEnergyType, : core::scoring::LREnergyContainer) → None¶: C++: core::scoring::Energies::set_long_range_container(enum core::scoring::methods::LongRangeEnergyType, class std::shared_ptr<class core::scoring::LREnergyContainer>) –> void

set_minimization_graph(self: pyrosetta.rosetta.core.scoring.Energies, : core::scoring::MinimizationGraph) → None¶: C++: core::scoring::Energies::set_minimization_graph(class std::shared_ptr<class core::scoring::MinimizationGraph>) –> void

set_nblist(self: pyrosetta.rosetta.core.scoring.Energies, type: pyrosetta.rosetta.core.scoring.EnergiesCacheableDataType.Enum, nblist_in: core::scoring::NeighborList) → None¶: C++: core::scoring::Energies::set_nblist(const enum core::scoring::EnergiesCacheableDataType::Enum &, class std::shared_ptr<class core::scoring::NeighborList>) –> void

set_owner(self: pyrosetta.rosetta.core.scoring.Energies, owner: pyrosetta.rosetta.core.pose.Pose) → None¶

Pose must claim its Energies object; this should happen once,: at the time the Pose is allocated. Future copying of the Energies object will not change ownership. The purpose of ownership is to allow lazy context-graph creation. When context graphs are requested that have not been created, they must be created and their edges must be updated to represent the current conformation of the pose.

C++: core::scoring::Energies::set_owner(class core::pose::Pose *) –> void

set_use_nblist(self: pyrosetta.rosetta.core.scoring.Energies, pose: pyrosetta.rosetta.core.pose.Pose, domain_map_in: ObjexxFCL::FArray1D<int>, use_nblist_auto_update: bool) → None¶: C++: core::scoring::Energies::set_use_nblist(const class core::pose::Pose &, const class ObjexxFCL::FArray1D<int> &, const bool) –> void

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.core.scoring.Energies, out: pyrosetta.rosetta.std.ostream) -> None

C++: core::scoring::Energies::show(class std::basic_ostream<char> &) const –> void

show(self: pyrosetta.rosetta.core.scoring.Energies, out: pyrosetta.rosetta.std.ostream, res: int) -> None

C++: core::scoring::Energies::show(class std::basic_ostream<char> &, unsigned long) const –> void

show(self: pyrosetta.rosetta.core.scoring.Energies) -> None

C++: core::scoring::Energies::show() const –> void

show(self: pyrosetta.rosetta.core.scoring.Energies, res: int) -> None

Shows the energy information of residue <seqpos>

: wrapper function of energies.show(Size) for Pyrosetta

example(s):

pose.energies().show(3)

See also:

Energies Energies.residue_total_energies Energies.residue_total_energy Pose ScoreFunction ScoreFunction.show create_score_function

C++: core::scoring::Energies::show(unsigned long) const –> void

show_total_headers(self: pyrosetta.rosetta.core.scoring.Energies, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::Energies::show_total_headers(class std::basic_ostream<char> &) const –> void

show_totals(self: pyrosetta.rosetta.core.scoring.Energies, out: pyrosetta.rosetta.std.ostream) → None¶: C++: core::scoring::Energies::show_totals(class std::basic_ostream<char> &) const –> void

size(self: pyrosetta.rosetta.core.scoring.Energies) → int¶

Returns the number of held residue energies

example(s):

r3 = pose.energies().residue_total_energies(3) r3[fa_sol]

See also:

Energies Energies.residue_total_energies Energies.residue_total_energy Pose ScoreFunction ScoreFunction.show create_score_function

C++: core::scoring::Energies::size() const –> unsigned long

structure_has_moved(self: pyrosetta.rosetta.core.scoring.Energies, nres: int) → None¶

called (eg by pose) to notify us of a change to the structure

Triggers clearing of the total energies and the twobody rsd energies PHIL – should also mark the neighbor links as invalid somehow… Called by pose when someone tries to access us, if the Conformation indicates that the structure has moved since the last score evaluation

const b/c called inside const access methods

C++: core::scoring::Energies::structure_has_moved(const unsigned long) const –> void

tenA_neighbor_graph(self: pyrosetta.rosetta.core.scoring.Energies) → pyrosetta.rosetta.core.scoring.TenANeighborGraph¶

Write access to the graph encoding # neighbors within 10 Angstroms: If the graph has not been requested up until this point, then it will be instantiated and filled. If the pose has changed size since the last score function evaluation (or if the pose has never been scored) this function will exit.

C++: core::scoring::Energies::tenA_neighbor_graph() –> class core::scoring::TenANeighborGraph &

total_energies(self: pyrosetta.rosetta.core.scoring.Energies) → pyrosetta.rosetta.core.scoring.EMapVector¶

Returns a non-const reference to the total_energies EnergyMap: so that external sources may append additional information to the Energies object. This is primarily useful for outputting score data with structures when those terms are not part of the energy function. This function will update the component energies if they are not up-to-date.

C++: core::scoring::Energies::total_energies() –> class core::scoring::EMapVector &

total_energy(self: pyrosetta.rosetta.core.scoring.Energies) → float¶: C++: core::scoring::Energies::total_energy() –> double &

twelveA_neighbor_graph(self: pyrosetta.rosetta.core.scoring.Energies) → core::scoring::TwelveANeighborGraph¶: C++: core::scoring::Energies::twelveA_neighbor_graph() –> class core::scoring::TwelveANeighborGraph &

update_residue_neighbors(self: pyrosetta.rosetta.core.scoring.Energies, domain_map_in: ObjexxFCL::FArray1D<int>, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

update the residue neighbors

C++: core::scoring::Energies::update_residue_neighbors(const class ObjexxFCL::FArray1D<int> &, const class core::pose::Pose &) –> void

use_nblist(self: pyrosetta.rosetta.core.scoring.Energies) → bool¶: C++: core::scoring::Energies::use_nblist() const –> bool

use_nblist_auto_update(self: pyrosetta.rosetta.core.scoring.Energies) → bool¶: C++: core::scoring::Energies::use_nblist_auto_update() const –> bool

use_nblist_of_type(self: pyrosetta.rosetta.core.scoring.Energies, type: pyrosetta.rosetta.core.scoring.EnergiesCacheableDataType.Enum) → bool¶: C++: core::scoring::Energies::use_nblist_of_type(const enum core::scoring::EnergiesCacheableDataType::Enum &) const –> bool

weights(*args, **kwargs)¶

Overloaded function.

weights(self: pyrosetta.rosetta.core.scoring.Energies) -> pyrosetta.rosetta.core.scoring.EMapVector

Returns an EnergyMap of the ScoreFunction weights from the last

scoring

example(s):: we = pose.energies().weights() we[fa_atr]
See also:: Energies Energies.residue_total_energies Energies.residue_total_energy Pose ScoreFunction ScoreFunction.show create_score_function EMapVector

C++: core::scoring::Energies::weights() const –> class core::scoring::EMapVector

weights(self: pyrosetta.rosetta.core.scoring.Energies, new_weights: pyrosetta.rosetta.core.scoring.EMapVector) -> None

Setter for the weights in this Energies object.

C++: core::scoring::Energies::weights(class core::scoring::EMapVector) –> void

class pyrosetta.rosetta.core.scoring.EnergyEdge¶

Bases: pyrosetta.rosetta.utility.graph.Edge

Class EnergyEdge holds scores for pair interactions for short-ranged energy functions. It also records whether or not it has been scored – when an edge is added to the graph, it sets “energies_computed_” as false, and the ScoreFunction class marks edges as having their energies computed once it computes them.

add_to_energy_map(*args, **kwargs)¶

Overloaded function.

add_to_energy_map(self: pyrosetta.rosetta.core.scoring.EnergyEdge, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

Add the non-zero elements into the energy map

C++: core::scoring::EnergyEdge::add_to_energy_map(class core::scoring::EMapVector &) const –> void

add_to_energy_map(self: pyrosetta.rosetta.core.scoring.EnergyEdge, emap: pyrosetta.rosetta.core.scoring.EMapVector, subset: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType) -> None

Add the non-zero elements into the energy map

C++: core::scoring::EnergyEdge::add_to_energy_map(class core::scoring::EMapVector &, const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &) const –> void

copy_from(self: pyrosetta.rosetta.core.scoring.EnergyEdge, source: pyrosetta.rosetta.utility.graph.Edge) → None¶

Copy the data held on the example edge, source.: The source edge must be castable to class EnergyEdge.

C++: core::scoring::EnergyEdge::copy_from(const class utility::graph::Edge *) –> void

count_dynamic_memory(self: pyrosetta.rosetta.core.scoring.EnergyEdge) → int¶: C++: core::scoring::EnergyEdge::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.core.scoring.EnergyEdge) → int¶: C++: core::scoring::EnergyEdge::count_static_memory() const –> unsigned long

dot(self: pyrosetta.rosetta.core.scoring.EnergyEdge, weights: pyrosetta.rosetta.core.scoring.EMapVector) → float¶

Compute the weighted energy for the components stored on this edge

C++: core::scoring::EnergyEdge::dot(const class core::scoring::EMapVector &) const –> double

dot_abs(self: pyrosetta.rosetta.core.scoring.EnergyEdge, weights: pyrosetta.rosetta.core.scoring.EMapVector) → float¶

Compute the weighted energy for the absolute value of the components stored on this edge

C++: core::scoring::EnergyEdge::dot_abs(const class core::scoring::EMapVector &) const –> double

energies_not_yet_computed(self: pyrosetta.rosetta.core.scoring.EnergyEdge) → bool¶: C++: core::scoring::EnergyEdge::energies_not_yet_computed() const –> bool

fill_energy_map(self: pyrosetta.rosetta.core.scoring.EnergyEdge) → pyrosetta.rosetta.core.scoring.EMapVector¶

Load an energy map with the non-zero

C++: core::scoring::EnergyEdge::fill_energy_map() const –> class core::scoring::EMapVector

get_first_node_ind(self: pyrosetta.rosetta.utility.graph.Edge) → int¶

returns the index of the lower node

C++: utility::graph::Edge::get_first_node_ind() const –> unsigned long

get_other_ind(self: pyrosetta.rosetta.utility.graph.Edge, node_index: int) → int¶

returns the index of the one node given the index of the other.: node_index must be one of the two nodes that this edge is incident upon.

C++: utility::graph::Edge::get_other_ind(unsigned long) const –> unsigned long

get_other_node(self: pyrosetta.rosetta.utility.graph.Edge, node_index: int) → pyrosetta.rosetta.utility.graph.Node¶

returns a non-const pointer to one node given the index of the other.: node_index must be one of the two nodes that this edge is incident upon.

C++: utility::graph::Edge::get_other_node(unsigned long) –> class utility::graph::Node *

get_second_node_ind(self: pyrosetta.rosetta.utility.graph.Edge) → int¶

returns the index of the upper node

C++: utility::graph::Edge::get_second_node_ind() const –> unsigned long

is_loop(self: pyrosetta.rosetta.utility.graph.Edge) → bool¶

Is this edge a loop? In Pseudographs, loop edges are incident twice on a single vertex.

C++: utility::graph::Edge::is_loop() const –> bool

mark_energies_computed(self: pyrosetta.rosetta.core.scoring.EnergyEdge) → None¶: C++: core::scoring::EnergyEdge::mark_energies_computed() –> void

mark_energies_uncomputed(self: pyrosetta.rosetta.core.scoring.EnergyEdge) → None¶: C++: core::scoring::EnergyEdge::mark_energies_uncomputed() –> void

same_edge(self: pyrosetta.rosetta.utility.graph.Edge, node1: int, node2: int) → bool¶

Is this the same edge as another edge (node1,node2)? Note:: this graph does not work for multi-graphs. Edges must be unique.

C++: utility::graph::Edge::same_edge(unsigned long, unsigned long) const –> bool

set_pos_in_owners_list(self: pyrosetta.rosetta.utility.graph.Edge, edge_iterator: pyrosetta.rosetta.utility.graph.EdgeListIterator) → None¶

called only by class Graph, this function gives the Edge the data it needs: to later delete itself from its owner’s edge list in constant time.

C++: utility::graph::Edge::set_pos_in_owners_list(class utility::graph::EdgeListIterator) –> void

square_distance(*args, **kwargs)¶

Overloaded function.

square_distance(self: pyrosetta.rosetta.core.scoring.EnergyEdge) -> float

C++: core::scoring::EnergyEdge::square_distance() const –> double

square_distance(self: pyrosetta.rosetta.core.scoring.EnergyEdge, dsqr: float) -> None

C++: core::scoring::EnergyEdge::square_distance(double) –> void

store_active_energies(*args, **kwargs)¶

Overloaded function.

store_active_energies(self: pyrosetta.rosetta.core.scoring.EnergyEdge, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

Store the energies held in the input emap on this edge; only: those ScoreTypes which are active are stored.

C++: core::scoring::EnergyEdge::store_active_energies(const class core::scoring::EMapVector &) –> void

store_active_energies(self: pyrosetta.rosetta.core.scoring.EnergyEdge, emap: pyrosetta.rosetta.core.scoring.EMapVector, subset: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType) -> None

Store the intersection of the energies held in the input emap on this edge:: The intersection is between the set of active ScoreTypes and the ScoreTypes given in the input “subset” list. subset need not be sorted.

C++: core::scoring::EnergyEdge::store_active_energies(const class core::scoring::EMapVector &, const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &) –> void

class pyrosetta.rosetta.core.scoring.EnergyGraph¶

Bases: pyrosetta.rosetta.utility.graph.Graph

Class to hold the component energies between pairs of residues. Each node represents a residue in its corresponding structure. Each edge in the graph holds a two-body energy map representing the unweighted components of the energy function for those terms with non-zero weight. The EnergyGraph may be accessed from the pose’s Energies object, but at a price of an extra score evaluation. This second score evaluation may be avoided if you use the ScoreFunction::score_components( pose ) method.

active_2b_score_types(self: pyrosetta.rosetta.core.scoring.EnergyGraph) → pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType¶: C++: core::scoring::EnergyGraph::active_2b_score_types() const –> const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &

active_score_types(self: pyrosetta.rosetta.core.scoring.EnergyGraph, active: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType) → bool¶

Set the active score types, and return true if the new score types: are the same as the old score types and the graph state is still good. Returns false if the score types have changed, indicating that the graph has dropped all of its edges;

C++: core::scoring::EnergyGraph::active_score_types(const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &) –> bool

add_edge(*args, **kwargs)¶

Overloaded function.

add_edge(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) -> pyrosetta.rosetta.utility.graph.Edge

add an edge between two vertices. Invokes “create_edge” from the derived class.: Returns a pointer to the edge after its been added, allowing the calling function to immediately set data for this edge.

C++: utility::graph::Graph::add_edge(unsigned long, unsigned long) –> class utility::graph::Edge *

add_edge(self: pyrosetta.rosetta.utility.graph.Graph, example_edge: pyrosetta.rosetta.utility.graph.Edge) -> pyrosetta.rosetta.utility.graph.Edge

add an edge to this graph copying the data from an edge in another graph.: Returns a pointer to the edge after its been added, allowing the calling function to immediately set data for this edge.

C++: utility::graph::Graph::add_edge(const class utility::graph::Edge *) –> class utility::graph::Edge *

add_energy_edge(self: pyrosetta.rosetta.core.scoring.EnergyGraph, index1: int, index2: int, dsq: float) → None¶

Add an energy edge to the graph and store the square distance

C++: core::scoring::EnergyGraph::add_energy_edge(unsigned long, unsigned long, double) –> void

all_pairs_shortest_paths(self: pyrosetta.rosetta.utility.graph.Graph) → ObjexxFCL::FArray2D<int>¶

O(V^3). Computes all pairs shortest paths using Warshall’s algorithm: and writes all the path distances to the two-dimensional table.

C++: utility::graph::Graph::all_pairs_shortest_paths() const –> class ObjexxFCL::FArray2D<int>

array_pool(self: pyrosetta.rosetta.core.scoring.EnergyGraph) → pyrosetta.rosetta.utility.graph.ArrayPool_double_t¶

Give non-const access to the array pool – this function should only: be called by class EnergyEdge. I wish C++ let me declare this function private and that EnergyEdge could be a “friend” of this function.

C++: core::scoring::EnergyGraph::array_pool() –> class utility::graph::ArrayPool<double> &

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

const_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the beginning of the (unordered) edge list for the graph.: this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::const_edge_list_begin() const –> class utility::graph::EdgeListConstIterator

const_edge_list_end(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the end of the (unordered) edge list for the graph.: this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::const_edge_list_end() const –> class utility::graph::EdgeListConstIterator

copy_connectivity(self: pyrosetta.rosetta.utility.graph.Graph, source: pyrosetta.rosetta.utility.graph.Graph) → None¶

copy the edge connectivity from a source graph with a potentially: unknown type.

C++: utility::graph::Graph::copy_connectivity(const class utility::graph::Graph &) –> void

deallocate_arraypoolelement(self: pyrosetta.rosetta.core.scoring.EnergyGraph, element: pyrosetta.rosetta.utility.graph.ArrayPoolElement_double_t) → None¶

As an edge is deleted from the graph, it must reliquish hold over its: array-pool element so that the element may be reused by new edges.

C++: core::scoring::EnergyGraph::deallocate_arraypoolelement(class utility::graph::ArrayPoolElement<double> &) –> void

delete_edge(self: pyrosetta.rosetta.core.scoring.EnergyGraph, edge: pyrosetta.rosetta.utility.graph.Edge) → None¶: C++: core::scoring::EnergyGraph::delete_edge(class utility::graph::Edge *) –> void

drop_all_edges(self: pyrosetta.rosetta.utility.graph.Graph) → None¶

delete all the edges present in the graph

C++: utility::graph::Graph::drop_all_edges() –> void

drop_all_edges_for_node(self: pyrosetta.rosetta.utility.graph.Graph, node: int) → None¶

delete all the edges for a single vertex in the graph

C++: utility::graph::Graph::drop_all_edges_for_node(unsigned long) –> void

edge_list_begin(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListIterator¶

returns a non-const iterator to the beginning of the (unordered) edge list for the graph.: this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::edge_list_begin() –> class utility::graph::EdgeListIterator

edge_list_end(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListIterator¶

returns a non-const iterator to the end of the (unordered) edge list for the graph.: this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::edge_list_end() –> class utility::graph::EdgeListIterator

find_edge(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) → pyrosetta.rosetta.utility.graph.Edge¶

returns a pointer to the edge connecting nodes node1 and node2, if that edge exists: in the graph, o.w. returns 0. Focuses the graph on this edge for fast subsequent retrieval.

C++: utility::graph::Graph::find_edge(unsigned long, unsigned long) –> class utility::graph::Edge *

find_energy_edge(self: pyrosetta.rosetta.core.scoring.EnergyGraph, n1: int, n2: int) → pyrosetta.rosetta.core.scoring.EnergyEdge¶: C++: core::scoring::EnergyGraph::find_energy_edge(unsigned long, unsigned long) –> class core::scoring::EnergyEdge *

focused_edge(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.Edge¶

returns a pointer to the focused edge

C++: utility::graph::Graph::focused_edge() –> class utility::graph::Edge *

getTotalMemoryUsage(self: pyrosetta.rosetta.utility.graph.Graph) → int¶

returns a count of all the memory used by every vertex and edge in a graph: by invoking the polymorphic count_static_memory and count_dynamic_memory of each (possibly derived) node and edge object as well as for the (possibly derived) graph class.

C++: utility::graph::Graph::getTotalMemoryUsage() const –> unsigned long

get_edge_exists(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) → bool¶

is an edge already present in the graph? O(V) worst case. O(1) iff all vertices have O(1) edges

C++: utility::graph::Graph::get_edge_exists(unsigned long, unsigned long) const –> bool

get_energy_node(self: pyrosetta.rosetta.core.scoring.EnergyGraph, index: int) → pyrosetta.rosetta.core.scoring.EnergyNode¶: C++: core::scoring::EnergyGraph::get_energy_node(unsigned long) –> class core::scoring::EnergyNode *

get_node(self: pyrosetta.rosetta.utility.graph.Graph, index: int) → pyrosetta.rosetta.utility.graph.Node¶: C++: utility::graph::Graph::get_node(unsigned long) –> class utility::graph::Node *

get_self_ptr(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.Graph¶: C++: utility::graph::Graph::get_self_ptr() –> class std::shared_ptr<class utility::graph::Graph>

n_active_score_types(self: pyrosetta.rosetta.core.scoring.EnergyGraph) → int¶: C++: core::scoring::EnergyGraph::n_active_score_types() const –> unsigned long

num_edges(self: pyrosetta.rosetta.utility.graph.Graph) → int¶: C++: utility::graph::Graph::num_edges() const –> unsigned long

num_nodes(self: pyrosetta.rosetta.utility.graph.Graph) → int¶

the number of nodes in the graph

C++: utility::graph::Graph::num_nodes() const –> unsigned long

output_connectivity(self: pyrosetta.rosetta.utility.graph.Graph, os: pyrosetta.rosetta.std.ostream) → None¶

send an edge list to the stream os.

C++: utility::graph::Graph::output_connectivity(class std::basic_ostream<char> &) const –> void

output_dimacs(self: pyrosetta.rosetta.utility.graph.Graph, os: pyrosetta.rosetta.std.ostream) → None¶

describe this graph in dimacs form to the stream os.

C++: utility::graph::Graph::output_dimacs(class std::basic_ostream<char> &) const –> void

print_vertices(self: pyrosetta.rosetta.utility.graph.Graph) → None¶

send summary information to the screen for all vertices in the graph

C++: utility::graph::Graph::print_vertices() const –> void

score_type_2_active(self: pyrosetta.rosetta.core.scoring.EnergyGraph) → pyrosetta.rosetta.utility.vector1_int¶: C++: core::scoring::EnergyGraph::score_type_2_active() const –> const class utility::vector1<int, class std::allocator<int> > &

set_num_nodes(self: pyrosetta.rosetta.utility.graph.Graph, num_nodes: int) → None¶

set the number of nodes in the graph – deletes any existing edges in the graph

C++: utility::graph::Graph::set_num_nodes(unsigned long) –> void

class pyrosetta.rosetta.core.scoring.EnergyNode¶

Bases: pyrosetta.rosetta.utility.graph.Node

Class EnergyNode holds the result of a domainmap update from the Conformation object held by a pose; if the internal degrees of freedom for a residue (corresponding to a node in this graph) have changed (and are marked with color “0” in the domainmap), then the EnergyNode object will hold that information for the ScoringFunction to retrieve

add_edge(self: pyrosetta.rosetta.utility.graph.Node, edge_ptr: utility::graph::Edge, : pyrosetta.rosetta.utility.graph.EdgeListIterator) → None¶

adds edge pointer to edge list; returns an iterator to the new: list element

C++: utility::graph::Node::add_edge(class utility::graph::Edge *, class utility::graph::EdgeListIterator &) –> void

const_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the beginning of its edge list

C++: utility::graph::Node::const_edge_list_begin() const –> class utility::graph::EdgeListConstIterator

const_edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the end of its edge list

C++: utility::graph::Node::const_edge_list_end() const –> class utility::graph::EdgeListConstIterator

const_lower_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the beginning of its lower-edge list

C++: utility::graph::Node::const_lower_edge_list_begin() const –> class utility::graph::EdgeListConstIterator

const_lower_edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the end of its lower-edge list

C++: utility::graph::Node::const_lower_edge_list_end() const –> class utility::graph::EdgeListConstIterator

const_upper_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the beginning of its upper-edge list

C++: utility::graph::Node::const_upper_edge_list_begin() const –> class utility::graph::EdgeListConstIterator

const_upper_edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the end of its upper-edge list

C++: utility::graph::Node::const_upper_edge_list_end() const –> class utility::graph::EdgeListConstIterator

copy_from(self: pyrosetta.rosetta.core.scoring.EnergyNode, source: pyrosetta.rosetta.utility.graph.Node) → None¶: C++: core::scoring::EnergyNode::copy_from(const class utility::graph::Node *) –> void

count_dynamic_memory(self: pyrosetta.rosetta.core.scoring.EnergyNode) → int¶: C++: core::scoring::EnergyNode::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.core.scoring.EnergyNode) → int¶: C++: core::scoring::EnergyNode::count_static_memory() const –> unsigned long

drop_all_edges(self: pyrosetta.rosetta.utility.graph.Node) → None¶

deletes all edges incident upon this node

C++: utility::graph::Node::drop_all_edges() –> void

drop_edge(self: pyrosetta.rosetta.utility.graph.Node, edge_iterator: pyrosetta.rosetta.utility.graph.EdgeListIterator) → None¶

removes an edge iterator from the node’s edge list. Only called by Edge class.

C++: utility::graph::Node::drop_edge(class utility::graph::EdgeListIterator) –> void

edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListIterator¶

returns a non-const iterator to the beginning of its edge list

C++: utility::graph::Node::edge_list_begin() –> class utility::graph::EdgeListIterator

edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListIterator¶

returns a non-const iterator to the end of its edge list

C++: utility::graph::Node::edge_list_end() –> class utility::graph::EdgeListIterator

find_edge(self: pyrosetta.rosetta.utility.graph.Node, other_node_index: int) → utility::graph::Edge¶: C++: utility::graph::Node::find_edge(unsigned long) –> class utility::graph::Edge *

get_node_index(self: pyrosetta.rosetta.utility.graph.Node) → int¶

the index for this node

C++: utility::graph::Node::get_node_index() const –> unsigned long

get_num_edges_to_larger_indexed_nodes(self: pyrosetta.rosetta.utility.graph.Node) → int¶

the number of upper neighbors – which “self” neighborness is counted if a loop edge: is present

C++: utility::graph::Node::get_num_edges_to_larger_indexed_nodes() const –> unsigned long

get_num_edges_to_smaller_indexed_nodes(self: pyrosetta.rosetta.utility.graph.Node) → int¶

the number of lower neighbors

C++: utility::graph::Node::get_num_edges_to_smaller_indexed_nodes() const –> unsigned long

loop_incident(self: pyrosetta.rosetta.utility.graph.Node) → bool¶

NOTE TO SELF: remove loop support

C++: utility::graph::Node::loop_incident() const –> bool

lower_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListIterator¶

returns a non-const iterator to the beginning of its lower-edge list

C++: utility::graph::Node::lower_edge_list_begin() –> class utility::graph::EdgeListIterator

lower_edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListIterator¶

returns a non-const iterator to the end of its lower-edge list

C++: utility::graph::Node::lower_edge_list_end() –> class utility::graph::EdgeListIterator

moved(*args, **kwargs)¶

Overloaded function.

moved(self: pyrosetta.rosetta.core.scoring.EnergyNode) -> bool

C++: core::scoring::EnergyNode::moved() const –> bool

moved(self: pyrosetta.rosetta.core.scoring.EnergyNode, : bool) -> None

C++: core::scoring::EnergyNode::moved(bool) –> void

num_edges(self: pyrosetta.rosetta.utility.graph.Node) → int¶

the number of edges incident on this node, which may include a loop edge

C++: utility::graph::Node::num_edges() const –> unsigned long

num_neighbors_counting_self(self: pyrosetta.rosetta.utility.graph.Node) → int¶

the number of neighbors counting “self” as a neighbor.

C++: utility::graph::Node::num_neighbors_counting_self() const –> unsigned long

num_neighbors_counting_self_static(self: pyrosetta.rosetta.utility.graph.Node) → int¶

the number of neighbors counting “self” as neighbor. Defaults to: num_neighbors_counting_self() but can be set to other values as well. Useful in calculation of symmetrical structures.

C++: utility::graph::Node::num_neighbors_counting_self_static() const –> unsigned long

print(self: pyrosetta.rosetta.core.scoring.EnergyNode) → None¶: C++: core::scoring::EnergyNode::print() const –> void

set_num_neighbors_counting_self_static(self: pyrosetta.rosetta.utility.graph.Node, neighbor: int) → None¶

manually change the number of neighbors for a Node. Used: for symmetry scoring

C++: utility::graph::Node::set_num_neighbors_counting_self_static(unsigned long) –> void

upper_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListIterator¶

returns a non-const iterator to the beginning of its upper-edge list

C++: utility::graph::Node::upper_edge_list_begin() –> class utility::graph::EdgeListIterator

upper_edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListIterator¶

returns a non-const iterator to the end of its upper-edge list

C++: utility::graph::Node::upper_edge_list_end() –> class utility::graph::EdgeListIterator

class pyrosetta.rosetta.core.scoring.FACTSPoseInfo¶

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

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

being_packed(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo, seqpos: int) → bool¶: C++: core::scoring::FACTSPoseInfo::being_packed(const unsigned long) const –> bool

clone(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: core::scoring::FACTSPoseInfo::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

context_derivative_empty(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo) → bool¶: C++: core::scoring::FACTSPoseInfo::context_derivative_empty() –> bool

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t¶: C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

initialize(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo, pose: pyrosetta.rosetta.core.pose.Pose, rsdtypemap: pyrosetta.rosetta.core.scoring.FACTSRsdTypeMap) → None¶: C++: core::scoring::FACTSPoseInfo::initialize(const class core::pose::Pose &, class core::scoring::FACTSRsdTypeMap &) –> void

is_changed(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo, pose: pyrosetta.rosetta.core.pose.Pose) → bool¶: C++: core::scoring::FACTSPoseInfo::is_changed(const class core::pose::Pose &) –> bool

placeholder_info(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo, seqpos: int) → pyrosetta.rosetta.core.scoring.FACTSResidueInfo¶: C++: core::scoring::FACTSPoseInfo::placeholder_info(const unsigned long) const –> const class core::scoring::FACTSResidueInfo &

placeholder_residue(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo, seqpos: int) → pyrosetta.rosetta.core.conformation.Residue¶: C++: core::scoring::FACTSPoseInfo::placeholder_residue(const unsigned long) const –> const class core::conformation::Residue &

residue_info(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo, i: int) → pyrosetta.rosetta.core.scoring.FACTSResidueInfo¶: C++: core::scoring::FACTSPoseInfo::residue_info(const unsigned long) –> class core::scoring::FACTSResidueInfo &

set_placeholder(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo, i: int, rsd: pyrosetta.rosetta.core.conformation.Residue, info: pyrosetta.rosetta.core.scoring.FACTSResidueInfo) → None¶: C++: core::scoring::FACTSPoseInfo::set_placeholder(const unsigned long, class std::shared_ptr<class core::conformation::Residue>, class std::shared_ptr<class core::scoring::FACTSResidueInfo>) –> void

set_repack_list(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo, repacking_residues: pyrosetta.rosetta.utility.vector1_bool) → None¶: C++: core::scoring::FACTSPoseInfo::set_repack_list(const class utility::vector1<bool, class std::allocator<bool> > &) –> void

size(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo) → int¶: C++: core::scoring::FACTSPoseInfo::size() const –> unsigned long

update_enumeration_shell(*args, **kwargs)¶

Overloaded function.

update_enumeration_shell(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> None
update_enumeration_shell(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo, pose: pyrosetta.rosetta.core.pose.Pose, enumerate_second_shell: bool) -> None

C++: core::scoring::FACTSPoseInfo::update_enumeration_shell(const class core::pose::Pose &, const bool) –> void

class pyrosetta.rosetta.core.scoring.FACTSPotential¶

Bases: pybind11_builtins.pybind11_object

eval_atom_nonpolar_derivative(self: pyrosetta.rosetta.core.scoring.FACTSPotential, id: pyrosetta.rosetta.core.id.AtomID, weight: float, pose: pyrosetta.rosetta.core.pose.Pose, : ObjexxFCL::FArray1D<int>, : bool, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶: C++: core::scoring::FACTSPotential::eval_atom_nonpolar_derivative(const class core::id::AtomID &, const double, const class core::pose::Pose &, const class ObjexxFCL::FArray1D<int> &, const bool, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

eval_atom_polar_derivative(self: pyrosetta.rosetta.core.scoring.FACTSPotential, id: pyrosetta.rosetta.core.id.AtomID, weight_elec: float, weight_solv: float, pose: pyrosetta.rosetta.core.pose.Pose, : ObjexxFCL::FArray1D<int>, : bool, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶: C++: core::scoring::FACTSPotential::eval_atom_polar_derivative(const class core::id::AtomID &, const double, const double, const class core::pose::Pose &, const class ObjexxFCL::FArray1D<int> &, const bool, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

evaluate_nonpolar_energy(self: pyrosetta.rosetta.core.scoring.FACTSPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, facts1: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, rsd2: pyrosetta.rosetta.core.conformation.Residue) → float¶: C++: core::scoring::FACTSPotential::evaluate_nonpolar_energy(const class core::conformation::Residue &, const class core::scoring::FACTSResidueInfo &, const class core::conformation::Residue &) const –> double

evaluate_polar_energy(self: pyrosetta.rosetta.core.scoring.FACTSPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, facts1: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, rsd2: pyrosetta.rosetta.core.conformation.Residue, E_elec: float, E_solv_self: float, E_solv_pair: float) → None¶: C++: core::scoring::FACTSPotential::evaluate_polar_energy(const class core::conformation::Residue &, const class core::scoring::FACTSResidueInfo &, const class core::conformation::Residue &, double &, double &, double &) const –> void

evaluate_polar_otf_energy(self: pyrosetta.rosetta.core.scoring.FACTSPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, facts1: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, rsd2: pyrosetta.rosetta.core.conformation.Residue, facts2: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, E_elec: float, E_solv_self: float, E_solv_pair: float) → None¶: C++: core::scoring::FACTSPotential::evaluate_polar_otf_energy(const class core::conformation::Residue &, const class core::scoring::FACTSResidueInfo &, const class core::conformation::Residue &, const class core::scoring::FACTSResidueInfo &, double &, double &, double &) const –> void

get_rotamers_born_radii(self: pyrosetta.rosetta.core.scoring.FACTSPotential, pose: pyrosetta.rosetta.core.pose.Pose, rotamer_set: pyrosetta.rosetta.core.conformation.RotamerSetBase) → None¶: C++: core::scoring::FACTSPotential::get_rotamers_born_radii(const class core::pose::Pose &, class core::conformation::RotamerSetBase &) const –> void

get_single_rotamer_born_radii(self: pyrosetta.rosetta.core.scoring.FACTSPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, facts_info: pyrosetta.rosetta.core.scoring.FACTSPoseInfo, facts1: pyrosetta.rosetta.core.scoring.FACTSResidueInfo) → None¶: C++: core::scoring::FACTSPotential::get_single_rotamer_born_radii(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::FACTSPoseInfo &, class core::scoring::FACTSResidueInfo &) const –> void

set_default(self: pyrosetta.rosetta.core.scoring.FACTSPotential) → None¶: C++: core::scoring::FACTSPotential::set_default() –> void

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.FACTSPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::FACTSPotential::setup_for_derivatives(class core::pose::Pose &) const –> void

setup_for_packing(self: pyrosetta.rosetta.core.scoring.FACTSPotential, pose: pyrosetta.rosetta.core.pose.Pose, repacking_residues: pyrosetta.rosetta.utility.vector1_bool) → None¶: C++: core::scoring::FACTSPotential::setup_for_packing(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.FACTSPotential, pose: pyrosetta.rosetta.core.pose.Pose, packing: bool) → None¶: C++: core::scoring::FACTSPotential::setup_for_scoring(class core::pose::Pose &, const bool &) const –> void

update_residue_for_packing(self: pyrosetta.rosetta.core.scoring.FACTSPotential, pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None¶: C++: core::scoring::FACTSPotential::update_residue_for_packing(class core::pose::Pose &, const unsigned long) const –> void

class pyrosetta.rosetta.core.scoring.FACTSResidueInfo¶

Bases: pybind11_builtins.pybind11_object

Ai(*args, **kwargs)¶

Overloaded function.

Ai(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) -> float

C++: core::scoring::FACTSResidueInfo::Ai(const unsigned long) const –> double

Ai(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo) -> pyrosetta.rosetta.utility.vector1_double

C++: core::scoring::FACTSResidueInfo::Ai() const –> const class utility::vector1<double, class std::allocator<double> > &

BR(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → float¶: C++: core::scoring::FACTSResidueInfo::BR(const unsigned long) const –> double

Bi(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → float¶: C++: core::scoring::FACTSResidueInfo::Bi(const unsigned long) const –> double

Ci(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → float¶: C++: core::scoring::FACTSResidueInfo::Ci(const unsigned long) const –> double

Di(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → float¶: C++: core::scoring::FACTSResidueInfo::Di(const unsigned long) const –> double

E_elec(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, res: int) → float¶: C++: core::scoring::FACTSResidueInfo::E_elec(const unsigned long) const –> double

E_solv(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, res: int) → float¶: C++: core::scoring::FACTSResidueInfo::E_solv(const unsigned long) const –> double

E_solv_pair(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, res: int) → float¶: C++: core::scoring::FACTSResidueInfo::E_solv_pair(const unsigned long) const –> double

E_solv_self(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, res: int) → float¶: C++: core::scoring::FACTSResidueInfo::E_solv_self(const unsigned long) const –> double

Ei(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → float¶: C++: core::scoring::FACTSResidueInfo::Ei(const unsigned long) const –> double

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

changed(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo) → bool¶: C++: core::scoring::FACTSResidueInfo::changed() const –> bool

clone(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo) → pyrosetta.rosetta.core.scoring.FACTSResidueInfo¶: C++: core::scoring::FACTSResidueInfo::clone() const –> class std::shared_ptr<class core::scoring::FACTSResidueInfo>

dBR_dG(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → float¶: C++: core::scoring::FACTSResidueInfo::dBR_dG(const unsigned long) const –> double

dB_dBdnmtr(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → float¶: C++: core::scoring::FACTSResidueInfo::dB_dBdnmtr(const unsigned long) const –> double

dB_dBnmtr(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → float¶: C++: core::scoring::FACTSResidueInfo::dB_dBnmtr(const unsigned long) const –> double

dG_dCi(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → float¶: C++: core::scoring::FACTSResidueInfo::dG_dCi(const unsigned long) const –> double

dSA_dDi(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → float¶: C++: core::scoring::FACTSResidueInfo::dSA_dDi(const unsigned long) const –> double

dnmtr(*args, **kwargs)¶

Overloaded function.

dnmtr(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo) -> pyrosetta.rosetta.utility.vector1_double

C++: core::scoring::FACTSResidueInfo::dnmtr() const –> const class utility::vector1<double, class std::allocator<double> > &

dnmtr(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) -> float

C++: core::scoring::FACTSResidueInfo::dnmtr(const unsigned long) const –> double

dsolv_dBR(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → float¶: C++: core::scoring::FACTSResidueInfo::dsolv_dBR(const unsigned long) const –> double

elecF2(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: core::scoring::FACTSResidueInfo::elecF2(const unsigned long) const –> class numeric::xyzVector<double>

enumeration_shell(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo) → bool¶: C++: core::scoring::FACTSResidueInfo::enumeration_shell() const –> bool

esolvE(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → float¶: C++: core::scoring::FACTSResidueInfo::esolvE(const unsigned long) const –> double

flag_for_calculation(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → bool¶: C++: core::scoring::FACTSResidueInfo::flag_for_calculation(const unsigned long) const –> bool

initialize(*args, **kwargs)¶

Overloaded function.

initialize(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, rsd: pyrosetta.rosetta.core.conformation.Residue, restypeinfo: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo) -> None
initialize(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, rsd: pyrosetta.rosetta.core.conformation.Residue, restypeinfo: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, is_rotamer: bool) -> None

C++: core::scoring::FACTSResidueInfo::initialize(const class core::conformation::Residue &, class std::shared_ptr<const class core::scoring::FACTSRsdTypeInfo>, const bool) –> void

natoms(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo) → int¶: C++: core::scoring::FACTSResidueInfo::natoms() const –> unsigned long

nmtr(*args, **kwargs)¶

Overloaded function.

nmtr(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo) -> pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t

C++: core::scoring::FACTSResidueInfo::nmtr() const –> const class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &

nmtr(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::FACTSResidueInfo::nmtr(const unsigned long) const –> class numeric::xyzVector<double>

refresh_energy_cache(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, nres: int) → None¶: C++: core::scoring::FACTSResidueInfo::refresh_energy_cache(const unsigned long) –> void

restypeinfo(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo) → pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo¶: C++: core::scoring::FACTSResidueInfo::restypeinfo() const –> class std::shared_ptr<const class core::scoring::FACTSRsdTypeInfo>

sasa(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → float¶: C++: core::scoring::FACTSResidueInfo::sasa(const unsigned long) const –> double

sasaF2(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: core::scoring::FACTSResidueInfo::sasaF2(const unsigned long) const –> class numeric::xyzVector<double>

set_changed(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, value: bool) → None¶: C++: core::scoring::FACTSResidueInfo::set_changed(const bool) –> void

set_enumeration_shell(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, value: bool) → None¶: C++: core::scoring::FACTSResidueInfo::set_enumeration_shell(const bool) –> void

solvF2BR(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: core::scoring::FACTSResidueInfo::solvF2BR(const unsigned long) const –> class numeric::xyzVector<double>

solvF2d(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: core::scoring::FACTSResidueInfo::solvF2d(const unsigned long) const –> class numeric::xyzVector<double>

store_xyz(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, rsd: pyrosetta.rosetta.core.conformation.Residue) → None¶: C++: core::scoring::FACTSResidueInfo::store_xyz(const class core::conformation::Residue &) –> void

xyz(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo) → pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t¶: C++: core::scoring::FACTSResidueInfo::xyz() const –> const class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &

class pyrosetta.rosetta.core.scoring.FACTSRotamerSetInfo¶

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

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

clone(self: pyrosetta.rosetta.core.scoring.FACTSRotamerSetInfo) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: core::scoring::FACTSRotamerSetInfo::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t¶: C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

initialize(self: pyrosetta.rosetta.core.scoring.FACTSRotamerSetInfo, rotamer_set: pyrosetta.rosetta.core.conformation.RotamerSetBase, rsdtypemap: pyrosetta.rosetta.core.scoring.FACTSRsdTypeMap) → None¶

dont forget to 0 the born_radii

C++: core::scoring::FACTSRotamerSetInfo::initialize(const class core::conformation::RotamerSetBase &, class core::scoring::FACTSRsdTypeMap &) –> void

residue_info(self: pyrosetta.rosetta.core.scoring.FACTSRotamerSetInfo, i: int) → pyrosetta.rosetta.core.scoring.FACTSResidueInfo¶: C++: core::scoring::FACTSRotamerSetInfo::residue_info(const unsigned long) –> class core::scoring::FACTSResidueInfo &

size(self: pyrosetta.rosetta.core.scoring.FACTSRotamerSetInfo) → int¶: C++: core::scoring::FACTSRotamerSetInfo::size() const –> unsigned long

class pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo¶

Bases: pybind11_builtins.pybind11_object

COradius2(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::COradius2(const unsigned long) const –> double

a0(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::a0(const unsigned long) const –> double

a1(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::a1(const unsigned long) const –> double

a2(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::a2(const unsigned long) const –> double

a3(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::a3(const unsigned long) const –> double

alpha(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::alpha(const unsigned long) const –> double

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

b1(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::b1(const unsigned long) const –> double

b2(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::b2(const unsigned long) const –> double

c0(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::c0(const unsigned long) const –> double

c1(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::c1(const unsigned long) const –> double

c2(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::c2(const unsigned long) const –> double

c3(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::c3(const unsigned long) const –> double

charged(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → bool¶: C++: core::scoring::FACTSRsdTypeInfo::charged(const unsigned long) const –> bool

create_info(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, rsd: pyrosetta.rosetta.core.chemical.ResidueType) → None¶: C++: core::scoring::FACTSRsdTypeInfo::create_info(const class core::chemical::ResidueType &) –> void

d1(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::d1(const unsigned long) const –> double

d2(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::d2(const unsigned long) const –> double

intra_elec_scale(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm1: int, atm2: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::intra_elec_scale(const unsigned long, const unsigned long) const –> double

intra_solv_scale(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm1: int, atm2: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::intra_solv_scale(const unsigned long, const unsigned long) const –> double

is_chargedH(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm1: int) → bool¶: C++: core::scoring::FACTSRsdTypeInfo::is_chargedH(const unsigned long) const –> bool

is_freedof(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm1: int) → bool¶: C++: core::scoring::FACTSRsdTypeInfo::is_freedof(const unsigned long) const –> bool

natoms(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo) → int¶: C++: core::scoring::FACTSRsdTypeInfo::natoms() const –> unsigned long

not_using(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → bool¶: C++: core::scoring::FACTSRsdTypeInfo::not_using(const unsigned long) const –> bool

q(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::q(const unsigned long) const –> double

volume(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo, atm: int) → float¶: C++: core::scoring::FACTSRsdTypeInfo::volume(const unsigned long) const –> double

class pyrosetta.rosetta.core.scoring.FACTSRsdTypeMap¶

Bases: pybind11_builtins.pybind11_object

The FACTSRsdTypeMap is a collection of FACTSRsdTypeInfo for a number of residue types (This is a separate class to shield the raw pointer usage here

get_type_info(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeMap, rsd_type: pyrosetta.rosetta.core.chemical.ResidueType) → pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo¶

get the info for the residue type, creating it if it doesn’t exist

C++: core::scoring::FACTSRsdTypeMap::get_type_info(const class core::chemical::ResidueType &) –> class std::shared_ptr<const class core::scoring::FACTSRsdTypeInfo>

restype_destruction_observer(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeMap, event: pyrosetta.rosetta.core.chemical.RestypeDestructionEvent) → None¶: C++: core::scoring::FACTSRsdTypeMap::restype_destruction_observer(const struct core::chemical::RestypeDestructionEvent &) –> void

class pyrosetta.rosetta.core.scoring.GenBornPoseInfo¶

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

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

being_packed(self: pyrosetta.rosetta.core.scoring.GenBornPoseInfo, seqpos: int) → bool¶: C++: core::scoring::GenBornPoseInfo::being_packed(const unsigned long) const –> bool

clone(self: pyrosetta.rosetta.core.scoring.GenBornPoseInfo) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: core::scoring::GenBornPoseInfo::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t¶: C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

initialize(self: pyrosetta.rosetta.core.scoring.GenBornPoseInfo, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::GenBornPoseInfo::initialize(const class core::pose::Pose &) –> void

placeholder_info(self: pyrosetta.rosetta.core.scoring.GenBornPoseInfo, seqpos: int) → pyrosetta.rosetta.core.scoring.GenBornResidueInfo¶: C++: core::scoring::GenBornPoseInfo::placeholder_info(const unsigned long) const –> const class core::scoring::GenBornResidueInfo &

placeholder_residue(self: pyrosetta.rosetta.core.scoring.GenBornPoseInfo, seqpos: int) → pyrosetta.rosetta.core.conformation.Residue¶: C++: core::scoring::GenBornPoseInfo::placeholder_residue(const unsigned long) const –> const class core::conformation::Residue &

residue_info(self: pyrosetta.rosetta.core.scoring.GenBornPoseInfo, i: int) → pyrosetta.rosetta.core.scoring.GenBornResidueInfo¶: C++: core::scoring::GenBornPoseInfo::residue_info(const unsigned long) –> class core::scoring::GenBornResidueInfo &

set_placeholder(self: pyrosetta.rosetta.core.scoring.GenBornPoseInfo, i: int, rsd: pyrosetta.rosetta.core.conformation.Residue, info: pyrosetta.rosetta.core.scoring.GenBornResidueInfo) → None¶: C++: core::scoring::GenBornPoseInfo::set_placeholder(const unsigned long, class std::shared_ptr<class core::conformation::Residue>, class std::shared_ptr<class core::scoring::GenBornResidueInfo>) –> void

set_repack_list(self: pyrosetta.rosetta.core.scoring.GenBornPoseInfo, repacking_residues: pyrosetta.rosetta.utility.vector1_bool) → None¶: C++: core::scoring::GenBornPoseInfo::set_repack_list(const class utility::vector1<bool, class std::allocator<bool> > &) –> void

size(self: pyrosetta.rosetta.core.scoring.GenBornPoseInfo) → int¶: C++: core::scoring::GenBornPoseInfo::size() const –> unsigned long

class pyrosetta.rosetta.core.scoring.GenBornPotential¶

Bases: pybind11_builtins.pybind11_object

eval_atom_derivative(self: pyrosetta.rosetta.core.scoring.GenBornPotential, id: pyrosetta.rosetta.core.id.AtomID, weight: float, pose: pyrosetta.rosetta.core.pose.Pose, domain_map: ObjexxFCL::FArray1D<int>, exclude_DNA_DNA: bool, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶: C++: core::scoring::GenBornPotential::eval_atom_derivative(const class core::id::AtomID &, const double, const class core::pose::Pose &, const class ObjexxFCL::FArray1D<int> &, const bool, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

get_all_born_radii(self: pyrosetta.rosetta.core.scoring.GenBornPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

called prior to scoring, eg

C++: core::scoring::GenBornPotential::get_all_born_radii(class core::pose::Pose &) const –> void

get_res_res_elecE(self: pyrosetta.rosetta.core.scoring.GenBornPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, gb1: pyrosetta.rosetta.core.scoring.GenBornResidueInfo, rsd2: pyrosetta.rosetta.core.conformation.Residue, gb2: pyrosetta.rosetta.core.scoring.GenBornResidueInfo) → float¶: C++: core::scoring::GenBornPotential::get_res_res_elecE(const class core::conformation::Residue &, const class core::scoring::GenBornResidueInfo &, const class core::conformation::Residue &, const class core::scoring::GenBornResidueInfo &) const –> double

get_rotamers_born_radii(self: pyrosetta.rosetta.core.scoring.GenBornPotential, pose: pyrosetta.rosetta.core.pose.Pose, rotamer_set: pyrosetta.rosetta.core.conformation.RotamerSetBase) → None¶: C++: core::scoring::GenBornPotential::get_rotamers_born_radii(const class core::pose::Pose &, class core::conformation::RotamerSetBase &) const –> void

setup_for_packing(self: pyrosetta.rosetta.core.scoring.GenBornPotential, pose: pyrosetta.rosetta.core.pose.Pose, repacking_residues: pyrosetta.rosetta.utility.vector1_bool) → None¶: C++: core::scoring::GenBornPotential::setup_for_packing(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &) const –> void

update_residue_for_packing(self: pyrosetta.rosetta.core.scoring.GenBornPotential, pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None¶: C++: core::scoring::GenBornPotential::update_residue_for_packing(class core::pose::Pose &, const unsigned long) const –> void

class pyrosetta.rosetta.core.scoring.GenBornResidueInfo¶

Bases: pybind11_builtins.pybind11_object

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

atomic_radius(self: pyrosetta.rosetta.core.scoring.GenBornResidueInfo, atm: int) → float¶: C++: core::scoring::GenBornResidueInfo::atomic_radius(const unsigned long) –> double &

born_radius(self: pyrosetta.rosetta.core.scoring.GenBornResidueInfo, atm: int) → float¶: C++: core::scoring::GenBornResidueInfo::born_radius(const unsigned long) –> double &

clone(self: pyrosetta.rosetta.core.scoring.GenBornResidueInfo) → pyrosetta.rosetta.core.scoring.GenBornResidueInfo¶: C++: core::scoring::GenBornResidueInfo::clone() const –> class std::shared_ptr<class core::scoring::GenBornResidueInfo>

initialize(self: pyrosetta.rosetta.core.scoring.GenBornResidueInfo, rsd: pyrosetta.rosetta.core.conformation.Residue) → None¶: C++: core::scoring::GenBornResidueInfo::initialize(const class core::conformation::Residue &) –> void

scale_factor(self: pyrosetta.rosetta.core.scoring.GenBornResidueInfo, atm: int) → float¶: C++: core::scoring::GenBornResidueInfo::scale_factor(const unsigned long) –> double &

size(self: pyrosetta.rosetta.core.scoring.GenBornResidueInfo) → int¶: C++: core::scoring::GenBornResidueInfo::size() const –> unsigned long

class pyrosetta.rosetta.core.scoring.GenBornRotamerSetInfo¶

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

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

clone(self: pyrosetta.rosetta.core.scoring.GenBornRotamerSetInfo) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: core::scoring::GenBornRotamerSetInfo::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t¶: C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

initialize(self: pyrosetta.rosetta.core.scoring.GenBornRotamerSetInfo, rotamer_set: pyrosetta.rosetta.core.conformation.RotamerSetBase) → None¶

dont forget to 0 the born_radii

C++: core::scoring::GenBornRotamerSetInfo::initialize(const class core::conformation::RotamerSetBase &) –> void

residue_info(self: pyrosetta.rosetta.core.scoring.GenBornRotamerSetInfo, i: int) → pyrosetta.rosetta.core.scoring.GenBornResidueInfo¶: C++: core::scoring::GenBornRotamerSetInfo::residue_info(const unsigned long) –> class core::scoring::GenBornResidueInfo &

size(self: pyrosetta.rosetta.core.scoring.GenBornRotamerSetInfo) → int¶: C++: core::scoring::GenBornRotamerSetInfo::size() const –> unsigned long

class pyrosetta.rosetta.core.scoring.GenericBondedPotential¶

Bases: pybind11_builtins.pybind11_object

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

residue_derivatives(self: pyrosetta.rosetta.core.scoring.GenericBondedPotential, rsd: pyrosetta.rosetta.core.conformation.Residue, weights: pyrosetta.rosetta.core.scoring.EMapVector, atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair) → None¶: C++: core::scoring::GenericBondedPotential::residue_derivatives(const class core::conformation::Residue &, const class core::scoring::EMapVector &, class utility::vector1<class core::scoring::DerivVectorPair, class std::allocator<class core::scoring::DerivVectorPair> > &) const –> void

residue_energy(self: pyrosetta.rosetta.core.scoring.GenericBondedPotential, rsd: pyrosetta.rosetta.core.conformation.Residue, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None¶: C++: core::scoring::GenericBondedPotential::residue_energy(const class core::conformation::Residue &, class core::scoring::EMapVector &) const –> void

residue_pair_derivatives(self: pyrosetta.rosetta.core.scoring.GenericBondedPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, weights: pyrosetta.rosetta.core.scoring.EMapVector, atom_derivs_r1: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair, atom_derivs_r2: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair) → None¶: C++: core::scoring::GenericBondedPotential::residue_pair_derivatives(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::scoring::EMapVector &, class utility::vector1<class core::scoring::DerivVectorPair, class std::allocator<class core::scoring::DerivVectorPair> > &, class utility::vector1<class core::scoring::DerivVectorPair, class std::allocator<class core::scoring::DerivVectorPair> > &) const –> void

residue_pair_energy(self: pyrosetta.rosetta.core.scoring.GenericBondedPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None¶: C++: core::scoring::GenericBondedPotential::residue_pair_energy(const class core::conformation::Residue &, const class core::conformation::Residue &, class core::scoring::EMapVector &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.GenericBondedPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::GenericBondedPotential::setup_for_scoring(class core::pose::Pose &) const –> void

class pyrosetta.rosetta.core.scoring.Hairpin¶

Bases: pybind11_builtins.pybind11_object

assign(self: pyrosetta.rosetta.core.scoring.Hairpin, s: pyrosetta.rosetta.core.scoring.Hairpin) → pyrosetta.rosetta.core.scoring.Hairpin¶

copy assignment

C++: core::scoring::Hairpin::operator=(const struct core::scoring::Hairpin &) –> struct core::scoring::Hairpin &

s1_end(self: pyrosetta.rosetta.core.scoring.Hairpin) → int¶: C++: core::scoring::Hairpin::s1_end() const –> unsigned long

s1_start(self: pyrosetta.rosetta.core.scoring.Hairpin) → int¶: C++: core::scoring::Hairpin::s1_start() const –> unsigned long

s2_end(self: pyrosetta.rosetta.core.scoring.Hairpin) → int¶: C++: core::scoring::Hairpin::s2_end() const –> unsigned long

s2_start(self: pyrosetta.rosetta.core.scoring.Hairpin) → int¶: C++: core::scoring::Hairpin::s2_start() const –> unsigned long

class pyrosetta.rosetta.core.scoring.Helices¶

Bases: pybind11_builtins.pybind11_object

assign(self: pyrosetta.rosetta.core.scoring.Helices, h: pyrosetta.rosetta.core.scoring.Helices) → pyrosetta.rosetta.core.scoring.Helices¶

copy assignment

C++: core::scoring::Helices::operator=(const struct core::scoring::Helices &) –> struct core::scoring::Helices &

resize(self: pyrosetta.rosetta.core.scoring.Helices, nres: int) → None¶: C++: core::scoring::Helices::resize(const int) –> void

class pyrosetta.rosetta.core.scoring.MembraneEmbed¶

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

Whole Pose Membrane Embedding

Define the embedding of the membrane pose based on computed: normal and center parameters. These are initialzed in the membrane protein framework and then recomputed based upon the structured and stored in MP residues (see MP Framework code)

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

calculated(self: pyrosetta.rosetta.core.scoring.MembraneEmbed) → bool¶

Return Non_Ref Calculated (no idea what this does - maybe observer)

C++: core::scoring::MembraneEmbed::calculated() –> bool &

center(self: pyrosetta.rosetta.core.scoring.MembraneEmbed) → pyrosetta.rosetta.numeric.xyzVector_double_t¶

Get Center Parameter

C++: core::scoring::MembraneEmbed::center() const –> const class numeric::xyzVector<double> &

clone(self: pyrosetta.rosetta.core.scoring.MembraneEmbed) → pyrosetta.rosetta.basic.datacache.CacheableData¶

Clone Cacheable Data

C++: core::scoring::MembraneEmbed::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

depth(self: pyrosetta.rosetta.core.scoring.MembraneEmbed, seqpos: int) → float¶

Compute depth of residue in the membrane

C++: core::scoring::MembraneEmbed::depth(const unsigned long) –> double &

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t¶: C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

initialize(self: pyrosetta.rosetta.core.scoring.MembraneEmbed, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Initialize Membrane Embedding From Pose??

C++: core::scoring::MembraneEmbed::initialize(const class core::pose::Pose &) –> void

normal(self: pyrosetta.rosetta.core.scoring.MembraneEmbed) → pyrosetta.rosetta.numeric.xyzVector_double_t¶

Get Normal Parameter

C++: core::scoring::MembraneEmbed::normal() const –> const class numeric::xyzVector<double> &

penalty(self: pyrosetta.rosetta.core.scoring.MembraneEmbed) → float¶

Get MP Penalty

C++: core::scoring::MembraneEmbed::penalty() const –> const double &

set_center(self: pyrosetta.rosetta.core.scoring.MembraneEmbed, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶

Set Pose Embedding Center (should not use this method, deprecated 3/11/14)

C++: core::scoring::MembraneEmbed::set_center(const class numeric::xyzVector<double> &) –> void

set_normal(self: pyrosetta.rosetta.core.scoring.MembraneEmbed, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶

Set Pose Embedding Normal (should not use this method, deprecated 3/11/14)

C++: core::scoring::MembraneEmbed::set_normal(const class numeric::xyzVector<double> &) –> void

set_penalty(self: pyrosetta.rosetta.core.scoring.MembraneEmbed, p: float) → None¶

Set Penalty

C++: core::scoring::MembraneEmbed::set_penalty(const double &) –> void

size(self: pyrosetta.rosetta.core.scoring.MembraneEmbed) → int¶

Compute Size of MP (]

C++: core::scoring::MembraneEmbed::size() const –> unsigned long

spanning(self: pyrosetta.rosetta.core.scoring.MembraneEmbed) → bool¶

Return Ref Spanning Parameter

C++: core::scoring::MembraneEmbed::spanning() –> bool &

pyrosetta.rosetta.core.scoring.MembraneEmbed_from_pose(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.scoring.MembraneEmbed¶

Add Const Membrane Embedding to the pose cache

C++: core::scoring::MembraneEmbed_from_pose(const class core::pose::Pose &) –> const class core::scoring::MembraneEmbed &

class pyrosetta.rosetta.core.scoring.MembranePotential¶

Bases: pyrosetta.rosetta.core.scoring.EnvPairPotential

Rosetta Membrane Low Resolution Scoring Methods

Compute scoring terms part of the Membrane Low resolution energy function. Developed: by Vladmir Yarov-Yaravoy et al. 2006. Includes Menv, MPair, MCBeta, and membrane alpha helical specific penalties. Framework tied.

Membed_init(self: pyrosetta.rosetta.core.scoring.MembranePotential) → bool¶

Initialize Membrane Embedding

C++: core::scoring::MembranePotential::Membed_init() const –> bool

Menv_penalties(self: pyrosetta.rosetta.core.scoring.MembranePotential) → bool¶

User Specified use penalties

C++: core::scoring::MembranePotential::Menv_penalties() const –> bool

cenlist_from_pose(: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.scoring.CenListInfo¶: C++: core::scoring::EnvPairPotential::cenlist_from_pose(const class core::pose::Pose &) –> const class core::scoring::CenListInfo &

compute_centroid_environment(self: pyrosetta.rosetta.core.scoring.EnvPairPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::EnvPairPotential::compute_centroid_environment(class core::pose::Pose &) const –> void

compute_membrane_embedding(self: pyrosetta.rosetta.core.scoring.MembranePotential, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Compute Membrane Embedding from pose and add Membed to Pose Cache

C++: core::scoring::MembranePotential::compute_membrane_embedding(class core::pose::Pose &) const –> void

evaluate_cbeta(self: pyrosetta.rosetta.core.scoring.MembranePotential, pose: pyrosetta.rosetta.core.pose.Pose, rsd: pyrosetta.rosetta.core.conformation.Residue, membrane_cb_score: float) → None¶

Evaluate CBeta Score (no idea…?)

C++: core::scoring::MembranePotential::evaluate_cbeta(const class core::pose::Pose &, const class core::conformation::Residue &, double &) const –> void

evaluate_env(*args, **kwargs)¶

Overloaded function.

evaluate_env(self: pyrosetta.rosetta.core.scoring.MembranePotential, pose: pyrosetta.rosetta.core.pose.Pose, rsd: pyrosetta.rosetta.core.conformation.Residue, MembraneDepth: float, membrane_env_score: float) -> None

Evalaute Membrane Environment

C++: core::scoring::MembranePotential::evaluate_env(const class core::pose::Pose &, const class core::conformation::Residue &, const double, double &) const –> void

evaluate_env(self: pyrosetta.rosetta.core.scoring.MembranePotential, pose: pyrosetta.rosetta.core.pose.Pose, rsd: pyrosetta.rosetta.core.conformation.Residue, membrane_env_score: float) -> None

C++: core::scoring::MembranePotential::evaluate_env(const class core::pose::Pose &, const class core::conformation::Residue &, double &) const –> void

evaluate_env_and_cbeta_scores(self: pyrosetta.rosetta.core.scoring.EnvPairPotential, pose: pyrosetta.rosetta.core.pose.Pose, rsd: pyrosetta.rosetta.core.conformation.Residue, env_score: float, cb_score6: float, cb_score12: float) → None¶: C++: core::scoring::EnvPairPotential::evaluate_env_and_cbeta_scores(const class core::pose::Pose &, const class core::conformation::Residue &, double &, double &, double &) const –> void

evaluate_pair(self: pyrosetta.rosetta.core.scoring.MembranePotential, pose: pyrosetta.rosetta.core.pose.Pose, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, cendist: float, membrane_pair_score: float) → None¶

Evaluate Energy For Two Residues

C++: core::scoring::MembranePotential::evaluate_pair(const class core::pose::Pose &, const class core::conformation::Residue &, const class core::conformation::Residue &, const double, double &) const –> void

evaluate_pair_and_cenpack_score(self: pyrosetta.rosetta.core.scoring.EnvPairPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, cendist: float, pair_contribution: float, cenpack_contribution: float) → None¶: C++: core::scoring::EnvPairPotential::evaluate_pair_and_cenpack_score(const class core::conformation::Residue &, const class core::conformation::Residue &, const double, double &, double &) const –> void

finalize(self: pyrosetta.rosetta.core.scoring.MembranePotential, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Finalize Setup of MP Potential Class

C++: core::scoring::MembranePotential::finalize(class core::pose::Pose &) const –> void

init_membrane_center_normal(self: pyrosetta.rosetta.core.scoring.MembranePotential, pose: pyrosetta.rosetta.core.pose.Pose, normal: pyrosetta.rosetta.numeric.xyzVector_double_t, center: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶

Initialize Membrane Center/Normal

C++: core::scoring::MembranePotential::init_membrane_center_normal(const class core::pose::Pose &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

non_helix_in_membrane_penalty(*args, **kwargs)¶

Overloaded function.

non_helix_in_membrane_penalty(self: pyrosetta.rosetta.core.scoring.MembranePotential, pose: pyrosetta.rosetta.core.pose.Pose, non_helix_in_membrane_penalty: float) -> None

Compute penaly for alpha helices that are not tm spanning

C++: core::scoring::MembranePotential::non_helix_in_membrane_penalty(const class core::pose::Pose &, double &) const –> void

non_helix_in_membrane_penalty(self: pyrosetta.rosetta.core.scoring.MembranePotential, pose: pyrosetta.rosetta.core.pose.Pose, normal: pyrosetta.rosetta.numeric.xyzVector_double_t, center: pyrosetta.rosetta.numeric.xyzVector_double_t, non_helix_in_membrane_penalty: float) -> None

C++: core::scoring::MembranePotential::non_helix_in_membrane_penalty(const class core::pose::Pose &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, double &) const –> void

nonconst_cenlist_from_pose(: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.scoring.CenListInfo¶: C++: core::scoring::EnvPairPotential::nonconst_cenlist_from_pose(class core::pose::Pose &) –> class core::scoring::CenListInfo &

termini_penalty(*args, **kwargs)¶

Overloaded function.

termini_penalty(self: pyrosetta.rosetta.core.scoring.MembranePotential, pose: pyrosetta.rosetta.core.pose.Pose, termini_penalty: float) -> None

Compute penalty for ???

C++: core::scoring::MembranePotential::termini_penalty(const class core::pose::Pose &, double &) const –> void

termini_penalty(self: pyrosetta.rosetta.core.scoring.MembranePotential, pose: pyrosetta.rosetta.core.pose.Pose, normal: pyrosetta.rosetta.numeric.xyzVector_double_t, center: pyrosetta.rosetta.numeric.xyzVector_double_t, termin_penalty: float) -> None

C++: core::scoring::MembranePotential::termini_penalty(const class core::pose::Pose &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, double &) const –> void

tm_projection_penalty(*args, **kwargs)¶

Overloaded function.

tm_projection_penalty(self: pyrosetta.rosetta.core.scoring.MembranePotential, pose: pyrosetta.rosetta.core.pose.Pose, tm_proj: float) -> None

Compute Transmembrane Spanning Projection Penalty (documentation for what this is - se MP potential from refactor)

C++: core::scoring::MembranePotential::tm_projection_penalty(const class core::pose::Pose &, double &) const –> void

tm_projection_penalty(self: pyrosetta.rosetta.core.scoring.MembranePotential, pose: pyrosetta.rosetta.core.pose.Pose, normal: pyrosetta.rosetta.numeric.xyzVector_double_t, center: pyrosetta.rosetta.numeric.xyzVector_double_t, tm_proj: float) -> None

C++: core::scoring::MembranePotential::tm_projection_penalty(const class core::pose::Pose &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, double &) const –> void

pyrosetta.rosetta.core.scoring.MembraneTopology_from_pose(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.scoring.MembraneTopology¶: C++: core::scoring::MembraneTopology_from_pose(const class core::pose::Pose &) –> const class core::scoring::MembraneTopology &

class pyrosetta.rosetta.core.scoring.Membrane_FAEmbed¶

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

Membrane Fullatom embedding info

Cacheable Data - Stores Full atom embedding information including: projection from z axis, fa depth, center, penalty, membrane thicnkess steepness and normal

Fa_Membed_update(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed) → bool¶: C++: core::scoring::Membrane_FAEmbed::Fa_Membed_update() –> bool &

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

calculated(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed) → bool¶: C++: core::scoring::Membrane_FAEmbed::calculated() –> bool &

clone(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed) → pyrosetta.rosetta.basic.datacache.CacheableData¶

Cacheable Data base Mehtod - Clone Object

C++: core::scoring::Membrane_FAEmbed::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

fa_center(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed) → float¶: C++: core::scoring::Membrane_FAEmbed::fa_center() –> double &

fa_depth(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed, seqpos: int, atom: int) → float¶

Compute Depth of Position in Membrane

C++: core::scoring::Membrane_FAEmbed::fa_depth(const unsigned long, const unsigned long) –> double &

fa_penalty(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed) → float¶: C++: core::scoring::Membrane_FAEmbed::fa_penalty() –> double &

fa_proj(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed, seqpos: int, atom: int) → float¶

Compute FA Proj to Z Axis

C++: core::scoring::Membrane_FAEmbed::fa_proj(const unsigned long, const unsigned long) –> double &

fa_proj_coord(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed, seqpos: int, atom: int) → pyrosetta.rosetta.numeric.xyzVector_double_t¶

Get Coordinates (I think it is storing these)

C++: core::scoring::Membrane_FAEmbed::fa_proj_coord(const unsigned long, const unsigned long) –> class numeric::xyzVector<double> &

fa_proj_deriv(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed, seqpos: int, atom: int) → float¶

Compute Derivative of Fa Proj.

C++: core::scoring::Membrane_FAEmbed::fa_proj_deriv(const unsigned long, const unsigned long) –> double &

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t¶: C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

initialize(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::Membrane_FAEmbed::initialize(const class core::pose::Pose &) –> void

steepness(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed) → float¶: C++: core::scoring::Membrane_FAEmbed::steepness() –> double &

thickness(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed) → float¶: C++: core::scoring::Membrane_FAEmbed::thickness() –> double &

pyrosetta.rosetta.core.scoring.Membrane_FAEmbed_from_pose(: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.scoring.Membrane_FAEmbed¶

Grab Const MP Fa Embedding data from the pose cache

C++: core::scoring::Membrane_FAEmbed_from_pose(const class core::pose::Pose &) –> const class core::scoring::Membrane_FAEmbed &

class pyrosetta.rosetta.core.scoring.Membrane_FAPotential¶

Bases: pyrosetta.rosetta.core.scoring.EnvPairPotential

Mmebrane Fullatom Potential - Scoring Class

Helper methods for computing fullatom energy terms: in the membrane scoring function

cenlist_from_pose(: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.scoring.CenListInfo¶: C++: core::scoring::EnvPairPotential::cenlist_from_pose(const class core::pose::Pose &) –> const class core::scoring::CenListInfo &

compute_centroid_environment(self: pyrosetta.rosetta.core.scoring.EnvPairPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::EnvPairPotential::compute_centroid_environment(class core::pose::Pose &) const –> void

compute_fa_projection(self: pyrosetta.rosetta.core.scoring.Membrane_FAPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::Membrane_FAPotential::compute_fa_projection(class core::pose::Pose &) const –> void

evaluate_env_and_cbeta_scores(self: pyrosetta.rosetta.core.scoring.EnvPairPotential, pose: pyrosetta.rosetta.core.pose.Pose, rsd: pyrosetta.rosetta.core.conformation.Residue, env_score: float, cb_score6: float, cb_score12: float) → None¶: C++: core::scoring::EnvPairPotential::evaluate_env_and_cbeta_scores(const class core::pose::Pose &, const class core::conformation::Residue &, double &, double &, double &) const –> void

evaluate_pair_and_cenpack_score(self: pyrosetta.rosetta.core.scoring.EnvPairPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, cendist: float, pair_contribution: float, cenpack_contribution: float) → None¶: C++: core::scoring::EnvPairPotential::evaluate_pair_and_cenpack_score(const class core::conformation::Residue &, const class core::conformation::Residue &, const double, double &, double &) const –> void

finalize(self: pyrosetta.rosetta.core.scoring.Membrane_FAPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Base Class Method - Finalize Scoring Setup

C++: core::scoring::Membrane_FAPotential::finalize(class core::pose::Pose &) const –> void

nonconst_cenlist_from_pose(: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.scoring.CenListInfo¶: C++: core::scoring::EnvPairPotential::nonconst_cenlist_from_pose(class core::pose::Pose &) –> class core::scoring::CenListInfo &

class pyrosetta.rosetta.core.scoring.MinimizationEdge¶

Bases: pyrosetta.rosetta.utility.graph.Edge

Class MinimizationEdge holds ResPairMinimizationData for a certain pair of interacting residues; this data might be a neighborlist for this residue pair, for example. The data held in this edge will be used in both scoring the residue-pair energies and evaluating atom derivatives during minimization.

active_2benmeths_begin(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationEdge::active_2benmeths_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

active_2benmeths_end(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationEdge::active_2benmeths_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

active_2benmeths_ext_begin(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationEdge::active_2benmeths_ext_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

active_2benmeths_ext_end(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationEdge::active_2benmeths_ext_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

active_2benmeths_std_begin(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationEdge::active_2benmeths_std_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

active_2benmeths_std_end(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationEdge::active_2benmeths_std_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

add_twobody_enmeth(self: pyrosetta.rosetta.core.scoring.MinimizationEdge, enmeth: core::scoring::methods::TwoBodyEnergy, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, residues_mwrt_eachother: bool) → bool¶

Include a particular energy method as part of this edge. It may not show up: in the active energy methods should this energy method not define an energy for the residues.

C++: core::scoring::MinimizationEdge::add_twobody_enmeth(class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, bool) –> bool

any_active_enmeths(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) → bool¶

It may be possible to determine that an edge does not need to belong to the: minimization graph if there are no active two-body energy methods; this is a convenience function that answers quickly if active_2benmths_.begin() == active_2benmeths_.end().

C++: core::scoring::MinimizationEdge::any_active_enmeths() const –> bool

copy_from(self: pyrosetta.rosetta.core.scoring.MinimizationEdge, source: pyrosetta.rosetta.utility.graph.Edge) → None¶

Copy the data held on the example edge, source.: The source edge must be castable to class MinimizationEdge.

C++: core::scoring::MinimizationEdge::copy_from(const class utility::graph::Edge *) –> void

count_dynamic_memory(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) → int¶: C++: core::scoring::MinimizationEdge::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) → int¶: C++: core::scoring::MinimizationEdge::count_static_memory() const –> unsigned long

dweight(*args, **kwargs)¶

Overloaded function.

dweight(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) -> float

C++: core::scoring::MinimizationEdge::dweight() const –> double

dweight(self: pyrosetta.rosetta.core.scoring.MinimizationEdge, setting: float) -> None

C++: core::scoring::MinimizationEdge::dweight(double) –> void

get_first_node_ind(self: pyrosetta.rosetta.utility.graph.Edge) → int¶

returns the index of the lower node

C++: utility::graph::Edge::get_first_node_ind() const –> unsigned long

get_other_ind(self: pyrosetta.rosetta.utility.graph.Edge, node_index: int) → int¶

returns the index of the one node given the index of the other.: node_index must be one of the two nodes that this edge is incident upon.

C++: utility::graph::Edge::get_other_ind(unsigned long) const –> unsigned long

get_other_node(self: pyrosetta.rosetta.utility.graph.Edge, node_index: int) → pyrosetta.rosetta.utility.graph.Node¶

returns a non-const pointer to one node given the index of the other.: node_index must be one of the two nodes that this edge is incident upon.

C++: utility::graph::Edge::get_other_node(unsigned long) –> class utility::graph::Node *

get_second_node_ind(self: pyrosetta.rosetta.utility.graph.Edge) → int¶

returns the index of the upper node

C++: utility::graph::Edge::get_second_node_ind() const –> unsigned long

is_loop(self: pyrosetta.rosetta.utility.graph.Edge) → bool¶

Is this edge a loop? In Pseudographs, loop edges are incident twice on a single vertex.

C++: utility::graph::Edge::is_loop() const –> bool

reinitialize_active_energy_methods(self: pyrosetta.rosetta.core.scoring.MinimizationEdge, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, res_moving_wrt_eachother: bool) → None¶

Setup the active and inactive energy methods

C++: core::scoring::MinimizationEdge::reinitialize_active_energy_methods(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, bool) –> void

res_pair_min_data(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) → pyrosetta.rosetta.core.scoring.ResPairMinimizationData¶: C++: core::scoring::MinimizationEdge::res_pair_min_data() –> class core::scoring::ResPairMinimizationData &

same_edge(self: pyrosetta.rosetta.utility.graph.Edge, node1: int, node2: int) → bool¶

Is this the same edge as another edge (node1,node2)? Note:: this graph does not work for multi-graphs. Edges must be unique.

C++: utility::graph::Edge::same_edge(unsigned long, unsigned long) const –> bool

set_pos_in_owners_list(self: pyrosetta.rosetta.utility.graph.Edge, edge_iterator: pyrosetta.rosetta.utility.graph.EdgeListIterator) → None¶

called only by class Graph, this function gives the Edge the data it needs: to later delete itself from its owner’s edge list in constant time.

C++: utility::graph::Edge::set_pos_in_owners_list(class utility::graph::EdgeListIterator) –> void

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.MinimizationEdge, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Initialize the active energy methods for derivative evaluation

C++: core::scoring::MinimizationEdge::setup_for_derivatives(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &) –> void

setup_for_minimizing(self: pyrosetta.rosetta.core.scoring.MinimizationEdge, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, min_map: pyrosetta.rosetta.core.kinematics.MinimizerMapBase) → None¶: C++: core::scoring::MinimizationEdge::setup_for_minimizing(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::kinematics::MinimizerMapBase &) –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.MinimizationEdge, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None¶

Initialize the active energy methods for score function evaluation

C++: core::scoring::MinimizationEdge::setup_for_scoring(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &) –> void

sfd_req_2benmeths_begin(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationEdge::sfd_req_2benmeths_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

sfd_req_2benmeths_end(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationEdge::sfd_req_2benmeths_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

sfs_req_2benmeths_begin(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationEdge::sfs_req_2benmeths_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

sfs_req_2benmeths_end(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationEdge::sfs_req_2benmeths_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

weight(*args, **kwargs)¶

Overloaded function.

weight(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) -> float

The minimization graph will allow the storage of edge weights, should that: prove useful for any application (e.g. symmetric minimization)

C++: core::scoring::MinimizationEdge::weight() const –> double

weight(self: pyrosetta.rosetta.core.scoring.MinimizationEdge, setting: float) -> None

Set the weight for an edge

C++: core::scoring::MinimizationEdge::weight(double) –> void

class pyrosetta.rosetta.core.scoring.MinimizationGraph¶

Bases: pyrosetta.rosetta.utility.graph.Graph

Class to hold all the minimization-specific data that’s required to efficiently evaluate the score function and its derivatives on a structure of fixed sequence and chemical identity.

add_edge(*args, **kwargs)¶

Overloaded function.

add_edge(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) -> pyrosetta.rosetta.utility.graph.Edge

add an edge between two vertices. Invokes “create_edge” from the derived class.: Returns a pointer to the edge after its been added, allowing the calling function to immediately set data for this edge.

C++: utility::graph::Graph::add_edge(unsigned long, unsigned long) –> class utility::graph::Edge *

add_edge(self: pyrosetta.rosetta.utility.graph.Graph, example_edge: pyrosetta.rosetta.utility.graph.Edge) -> pyrosetta.rosetta.utility.graph.Edge

add an edge to this graph copying the data from an edge in another graph.: Returns a pointer to the edge after its been added, allowing the calling function to immediately set data for this edge.

C++: utility::graph::Graph::add_edge(const class utility::graph::Edge *) –> class utility::graph::Edge *

add_whole_pose_context_enmeth(self: pyrosetta.rosetta.core.scoring.MinimizationGraph, enmeth: pyrosetta.rosetta.core.scoring.methods.EnergyMethod, pose: pyrosetta.rosetta.core.pose.Pose) → None¶: C++: core::scoring::MinimizationGraph::add_whole_pose_context_enmeth(class std::shared_ptr<const class core::scoring::methods::EnergyMethod>, const class core::pose::Pose &) –> void

all_pairs_shortest_paths(self: pyrosetta.rosetta.utility.graph.Graph) → ObjexxFCL::FArray2D<int>¶

O(V^3). Computes all pairs shortest paths using Warshall’s algorithm: and writes all the path distances to the two-dimensional table.

C++: utility::graph::Graph::all_pairs_shortest_paths() const –> class ObjexxFCL::FArray2D<int>

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

const_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the beginning of the (unordered) edge list for the graph.: this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::const_edge_list_begin() const –> class utility::graph::EdgeListConstIterator

const_edge_list_end(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the end of the (unordered) edge list for the graph.: this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::const_edge_list_end() const –> class utility::graph::EdgeListConstIterator

copy_connectivity(self: pyrosetta.rosetta.utility.graph.Graph, source: pyrosetta.rosetta.utility.graph.Graph) → None¶

copy the edge connectivity from a source graph with a potentially: unknown type.

C++: utility::graph::Graph::copy_connectivity(const class utility::graph::Graph &) –> void

delete_edge(self: pyrosetta.rosetta.core.scoring.MinimizationGraph, edge: pyrosetta.rosetta.utility.graph.Edge) → None¶: C++: core::scoring::MinimizationGraph::delete_edge(class utility::graph::Edge *) –> void

drop_all_edges(self: pyrosetta.rosetta.utility.graph.Graph) → None¶

delete all the edges present in the graph

C++: utility::graph::Graph::drop_all_edges() –> void

drop_all_edges_for_node(self: pyrosetta.rosetta.utility.graph.Graph, node: int) → None¶

delete all the edges for a single vertex in the graph

C++: utility::graph::Graph::drop_all_edges_for_node(unsigned long) –> void

edge_list_begin(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListIterator¶

returns a non-const iterator to the beginning of the (unordered) edge list for the graph.: this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::edge_list_begin() –> class utility::graph::EdgeListIterator

edge_list_end(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.EdgeListIterator¶

returns a non-const iterator to the end of the (unordered) edge list for the graph.: this edge list contains all the edges in the graph, not simply those for a particular vertex

C++: utility::graph::Graph::edge_list_end() –> class utility::graph::EdgeListIterator

find_edge(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) → pyrosetta.rosetta.utility.graph.Edge¶

returns a pointer to the edge connecting nodes node1 and node2, if that edge exists: in the graph, o.w. returns 0. Focuses the graph on this edge for fast subsequent retrieval.

C++: utility::graph::Graph::find_edge(unsigned long, unsigned long) –> class utility::graph::Edge *

find_minimization_edge(self: pyrosetta.rosetta.core.scoring.MinimizationGraph, n1: int, n2: int) → pyrosetta.rosetta.core.scoring.MinimizationEdge¶: C++: core::scoring::MinimizationGraph::find_minimization_edge(unsigned long, unsigned long) –> class core::scoring::MinimizationEdge *

fixed_energies(self: pyrosetta.rosetta.core.scoring.MinimizationGraph) → pyrosetta.rosetta.core.scoring.EMapVector¶: C++: core::scoring::MinimizationGraph::fixed_energies() const –> const class core::scoring::EMapVector &

focused_edge(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.Edge¶

returns a pointer to the focused edge

C++: utility::graph::Graph::focused_edge() –> class utility::graph::Edge *

getTotalMemoryUsage(self: pyrosetta.rosetta.utility.graph.Graph) → int¶

returns a count of all the memory used by every vertex and edge in a graph: by invoking the polymorphic count_static_memory and count_dynamic_memory of each (possibly derived) node and edge object as well as for the (possibly derived) graph class.

C++: utility::graph::Graph::getTotalMemoryUsage() const –> unsigned long

get_edge_exists(self: pyrosetta.rosetta.utility.graph.Graph, node1: int, node2: int) → bool¶

is an edge already present in the graph? O(V) worst case. O(1) iff all vertices have O(1) edges

C++: utility::graph::Graph::get_edge_exists(unsigned long, unsigned long) const –> bool

get_minimization_node(self: pyrosetta.rosetta.core.scoring.MinimizationGraph, index: int) → pyrosetta.rosetta.core.scoring.MinimizationNode¶: C++: core::scoring::MinimizationGraph::get_minimization_node(unsigned long) –> class core::scoring::MinimizationNode *

get_node(self: pyrosetta.rosetta.utility.graph.Graph, index: int) → pyrosetta.rosetta.utility.graph.Node¶: C++: utility::graph::Graph::get_node(unsigned long) –> class utility::graph::Node *

get_self_ptr(self: pyrosetta.rosetta.utility.graph.Graph) → pyrosetta.rosetta.utility.graph.Graph¶: C++: utility::graph::Graph::get_self_ptr() –> class std::shared_ptr<class utility::graph::Graph>

num_edges(self: pyrosetta.rosetta.utility.graph.Graph) → int¶: C++: utility::graph::Graph::num_edges() const –> unsigned long

num_nodes(self: pyrosetta.rosetta.utility.graph.Graph) → int¶

the number of nodes in the graph

C++: utility::graph::Graph::num_nodes() const –> unsigned long

output_connectivity(self: pyrosetta.rosetta.utility.graph.Graph, os: pyrosetta.rosetta.std.ostream) → None¶

send an edge list to the stream os.

C++: utility::graph::Graph::output_connectivity(class std::basic_ostream<char> &) const –> void

output_dimacs(self: pyrosetta.rosetta.utility.graph.Graph, os: pyrosetta.rosetta.std.ostream) → None¶

describe this graph in dimacs form to the stream os.

C++: utility::graph::Graph::output_dimacs(class std::basic_ostream<char> &) const –> void

print_vertices(self: pyrosetta.rosetta.utility.graph.Graph) → None¶

send summary information to the screen for all vertices in the graph

C++: utility::graph::Graph::print_vertices() const –> void

set_fixed_energies(self: pyrosetta.rosetta.core.scoring.MinimizationGraph, : pyrosetta.rosetta.core.scoring.EMapVector) → None¶: C++: core::scoring::MinimizationGraph::set_fixed_energies(const class core::scoring::EMapVector &) –> void

set_num_nodes(self: pyrosetta.rosetta.utility.graph.Graph, num_nodes: int) → None¶

set the number of nodes in the graph – deletes any existing edges in the graph

C++: utility::graph::Graph::set_num_nodes(unsigned long) –> void

whole_pose_context_enmeths_begin(self: pyrosetta.rosetta.core.scoring.MinimizationGraph) → std::_List_const_iterator<std::shared_ptr<core::scoring::methods::EnergyMethod const> >¶: C++: core::scoring::MinimizationGraph::whole_pose_context_enmeths_begin() const –> struct std::_List_const_iterator<class std::shared_ptr<const class core::scoring::methods::EnergyMethod> >

whole_pose_context_enmeths_end(self: pyrosetta.rosetta.core.scoring.MinimizationGraph) → std::_List_const_iterator<std::shared_ptr<core::scoring::methods::EnergyMethod const> >¶: C++: core::scoring::MinimizationGraph::whole_pose_context_enmeths_end() const –> struct std::_List_const_iterator<class std::shared_ptr<const class core::scoring::methods::EnergyMethod> >

class pyrosetta.rosetta.core.scoring.MinimizationNode¶

Bases: pyrosetta.rosetta.utility.graph.Node

Class MinimizationNode holds the ResSingleMinimizationData information for a single residue in a Pose which is being minimized. The data held in this node will be used in both scoring the residue one-body energies and evaluating atom derivatives during minimization.

active_1benmeths_begin(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::OneBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::active_1benmeths_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> > > >

active_1benmeths_end(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::OneBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::active_1benmeths_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> > > >

active_1benmeths_ext_begin(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::OneBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::active_1benmeths_ext_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> > > >

active_1benmeths_ext_end(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::OneBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::active_1benmeths_ext_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> > > >

active_1benmeths_std_begin(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::OneBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::active_1benmeths_std_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> > > >

active_1benmeths_std_end(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::OneBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::active_1benmeths_std_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> > > >

active_intrares2benmeths_begin(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::active_intrares2benmeths_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

active_intrares2benmeths_end(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::active_intrares2benmeths_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

active_intrares2benmeths_ext_begin(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::active_intrares2benmeths_ext_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

active_intrares2benmeths_ext_end(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::active_intrares2benmeths_ext_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

active_intrares2benmeths_std_begin(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::active_intrares2benmeths_std_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

active_intrares2benmeths_std_end(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::active_intrares2benmeths_std_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

add_edge(self: pyrosetta.rosetta.utility.graph.Node, edge_ptr: utility::graph::Edge, : pyrosetta.rosetta.utility.graph.EdgeListIterator) → None¶

adds edge pointer to edge list; returns an iterator to the new: list element

C++: utility::graph::Node::add_edge(class utility::graph::Edge *, class utility::graph::EdgeListIterator &) –> void

add_onebody_enmeth(self: pyrosetta.rosetta.core.scoring.MinimizationNode, enmeth: pyrosetta.rosetta.core.scoring.methods.OneBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, domain_map_color: int) → bool¶: C++: core::scoring::MinimizationNode::add_onebody_enmeth(class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy>, const class core::conformation::Residue &, const class core::pose::Pose &, int) –> bool

add_sfs_drs_enmeth(self: pyrosetta.rosetta.core.scoring.MinimizationNode, enmeth: pyrosetta.rosetta.core.scoring.methods.EnergyMethod) → None¶

This method is not meant for general use; it’s only to be called: by the MinimizationNode and the MinimizationGraph.

C++: core::scoring::MinimizationNode::add_sfs_drs_enmeth(class std::shared_ptr<const class core::scoring::methods::EnergyMethod>) –> void

add_twobody_enmeth(self: pyrosetta.rosetta.core.scoring.MinimizationNode, enmeth: core::scoring::methods::TwoBodyEnergy, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector, domain_map_color: int) → bool¶: C++: core::scoring::MinimizationNode::add_twobody_enmeth(class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::EMapVector &, int) –> bool

const_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the beginning of its edge list

C++: utility::graph::Node::const_edge_list_begin() const –> class utility::graph::EdgeListConstIterator

const_edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the end of its edge list

C++: utility::graph::Node::const_edge_list_end() const –> class utility::graph::EdgeListConstIterator

const_lower_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the beginning of its lower-edge list

C++: utility::graph::Node::const_lower_edge_list_begin() const –> class utility::graph::EdgeListConstIterator

const_lower_edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the end of its lower-edge list

C++: utility::graph::Node::const_lower_edge_list_end() const –> class utility::graph::EdgeListConstIterator

const_upper_edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the beginning of its upper-edge list

C++: utility::graph::Node::const_upper_edge_list_begin() const –> class utility::graph::EdgeListConstIterator

const_upper_edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListConstIterator¶

returns a const iterator to the end of its upper-edge list

C++: utility::graph::Node::const_upper_edge_list_end() const –> class utility::graph::EdgeListConstIterator

copy_from(self: pyrosetta.rosetta.core.scoring.MinimizationNode, source: pyrosetta.rosetta.utility.graph.Node) → None¶: C++: core::scoring::MinimizationNode::copy_from(const class utility::graph::Node *) –> void

count_dynamic_memory(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → int¶: C++: core::scoring::MinimizationNode::count_dynamic_memory() const –> unsigned long

count_static_memory(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → int¶: C++: core::scoring::MinimizationNode::count_static_memory() const –> unsigned long

dof_deriv_1benmeths_begin(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::OneBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::dof_deriv_1benmeths_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> > > >

dof_deriv_1benmeths_end(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::OneBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::OneBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::dof_deriv_1benmeths_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::OneBodyEnergy> > > >

dof_deriv_2benmeths_begin(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::dof_deriv_2benmeths_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

dof_deriv_2benmeths_end(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy const> > > >¶: C++: core::scoring::MinimizationNode::dof_deriv_2benmeths_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::TwoBodyEnergy> > > >

drop_all_edges(self: pyrosetta.rosetta.utility.graph.Node) → None¶

deletes all edges incident upon this node

C++: utility::graph::Node::drop_all_edges() –> void

drop_edge(self: pyrosetta.rosetta.utility.graph.Node, edge_iterator: pyrosetta.rosetta.utility.graph.EdgeListIterator) → None¶

removes an edge iterator from the node’s edge list. Only called by Edge class.

C++: utility::graph::Node::drop_edge(class utility::graph::EdgeListIterator) –> void

dweight(*args, **kwargs)¶

Overloaded function.

dweight(self: pyrosetta.rosetta.core.scoring.MinimizationNode) -> float

C++: core::scoring::MinimizationNode::dweight() const –> double

dweight(self: pyrosetta.rosetta.core.scoring.MinimizationNode, setting: float) -> None

C++: core::scoring::MinimizationNode::dweight(double) –> void

edge_list_begin(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListIterator¶

returns a non-const iterator to the beginning of its edge list

C++: utility::graph::Node::edge_list_begin() –> class utility::graph::EdgeListIterator

edge_list_end(self: pyrosetta.rosetta.utility.graph.Node) → pyrosetta.rosetta.utility.graph.EdgeListIterator¶

returns a non-const iterator to the end of its edge list

C++: utility::graph::Node::edge_list_end() –> class utility::graph::EdgeListIterator

find_edge(self: pyrosetta.rosetta.utility.graph.Node, other_node_index: int) → utility::graph::Edge¶: C++: utility::graph::Node::find_edge(unsigned long) –> class utility::graph::Edge *

get_node_index(self: pyrosetta.rosetta.utility.graph.Node) → int¶

the index for this node

C++: utility::graph::Node::get_node_index() const –> unsigned long

get_num_edges_to_larger_indexed_nodes(self: pyrosetta.rosetta.utility.graph.Node) → int¶

the number of upper neighbors – which “self” neighborness is counted if a loop edge: is present