scoring

• EnergiesCacheableDataType
• aa_composition_energy
• aa_repeat_energy
• annealing
• bin_transitions
• carbohydrates
• carbon_hbonds
• constraints
• cryst
• custom_pair_distance
• disulfides
• dna
• dssp
• elec
• electron_density
• electron_density_atomwise
• etable
• fiber_diffraction
• func
• geometric_solvation
• hackaro
• hbonds
• interface
• lkball
• loop_graph
• magnesium
• membrane
• methods
• mm
• motif
• nv
• orbitals
• packing
• packstat
• power_diagram
• rna
• sasa
• saxs
• sc
• solid_surface
• sym_e
• symmetry
• trie
• vdwaals

Bindings for core::scoring namespace

class pyrosetta.rosetta.core.scoring.APBSConfig

Bases: pybind11_builtins.pybind11_object

APBSConfig

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.APBSConfig, pose: pyrosetta.rosetta.core.pose.Pose, natoms: int, dbg: int, calcenergy: bool) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.APBSConfig, arg0: pyrosetta.rosetta.core.scoring.APBSConfig) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__

Initialize self. See help(type(self)) for accurate signature.

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.APBSWrapper, pose: pyrosetta.rosetta.core.pose.Pose, charged_residues: pyrosetta.rosetta.std.map_std_string_bool, dbg: int, calcenergy: bool) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.AtomNeighbor) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.AtomNeighbor, arg0: int, arg1: int, arg2: int, arg3: float) -> None

doc

3. __init__(self: pyrosetta.rosetta.core.scoring.AtomNeighbor, rsd_in: int, atomno_in: int, path_dist_in: int, weight_in: float, weight_func_in: float) -> None
4. __init__(self: pyrosetta.rosetta.core.scoring.AtomNeighbor, arg0: pyrosetta.rosetta.core.scoring.AtomNeighbor) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.BB_Pos, arg0: pyrosetta.rosetta.core.scoring.BB_Pos) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.BB_Pos) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

1. 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

2. 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

3. 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

4. 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 &, class std::list<unsigned long, class std::allocator<unsigned long> >, double &, double &, double &, double &, double &) –> double

5. 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 &, class std::list<unsigned long, class std::allocator<unsigned long> >) –> double

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

Overloaded function.

1. 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 &, class std::list<unsigned long, class std::allocator<unsigned long> >) –> void

2. 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

3. 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.

1. CA_maxsub(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) -> int
2. 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

3. CA_maxsub(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, residue_selection: pyrosetta.rosetta.std.list_unsigned_long_t) -> int
4. 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.

1. CA_or_equiv_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) -> float
2. CA_or_equiv_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, start: int) -> float
3. 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.

1. 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

2. CA_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) -> float
3. CA_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, start: int) -> float
4. 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

5. 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

6. 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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.CSA) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.CSA, res1: int, atom1: str, sigma1: float, sigma2: float, sigma3: float, CSAval: float, CSAerr: float, weight: float) -> None
3. __init__(self: pyrosetta.rosetta.core.scoring.CSA, arg0: pyrosetta.rosetta.core.scoring.CSA) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.scoring.CSA) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.CenListInfo) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.CenListInfo, arg0: pyrosetta.rosetta.core.scoring.CenListInfo) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.ChemicalShiftAnisotropy) -> None

doc

2. __init__(self: pyrosetta.rosetta.core.scoring.ChemicalShiftAnisotropy, filename: str) -> None
3. __init__(self: pyrosetta.rosetta.core.scoring.ChemicalShiftAnisotropy, arg0: pyrosetta.rosetta.core.scoring.ChemicalShiftAnisotropy) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.scoring.ChemicalShiftAnisotropy) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.DC

Bases: pybind11_builtins.pybind11_object

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.DC) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.DC, res1: int, atom1: str, res2: int, atom2: str, DCval: float, DCerr: float, weight: float) -> None
3. __init__(self: pyrosetta.rosetta.core.scoring.DC, arg0: pyrosetta.rosetta.core.scoring.DC) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.scoring.DC) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer, size_in: int, score_type_in: pyrosetta.rosetta.core.scoring.ScoreType) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.DenseEnergyContainer, arg0: pyrosetta.rosetta.core.scoring.DenseEnergyContainer) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(self: pyrosetta.rosetta.core.scoring.DenseNeighborConstIterator, other: pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator) → bool

C++: core::scoring::DenseNeighborConstIterator::operator==(const class core::scoring::ResidueNeighborConstIterator &) const –> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.DenseNeighborConstIterator, pos1_in: int, pos2_in: int, st: pyrosetta.rosetta.core.scoring.ScoreType, table_in: ObjexxFCL::FArray2D<double>, computed_in: ObjexxFCL::FArray2D<bool>) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(self: pyrosetta.rosetta.core.scoring.DenseNeighborConstIterator, other: pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator) → bool

C++: core::scoring::DenseNeighborConstIterator::operator!=(const class core::scoring::ResidueNeighborConstIterator &) const –> bool

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(self: pyrosetta.rosetta.core.scoring.DenseNeighborIterator, other: pyrosetta.rosetta.core.scoring.ResidueNeighborIterator) → bool

C++: core::scoring::DenseNeighborIterator::operator==(const class core::scoring::ResidueNeighborIterator &) const –> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.DenseNeighborIterator, pos1_in: int, pos2_in: int, st: pyrosetta.rosetta.core.scoring.ScoreType, table_in: ObjexxFCL::FArray2D<double>, computed_in: ObjexxFCL::FArray2D<bool>) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(self: pyrosetta.rosetta.core.scoring.DenseNeighborIterator, other: pyrosetta.rosetta.core.scoring.ResidueNeighborIterator) → bool

C++: core::scoring::DenseNeighborIterator::operator!=(const class core::scoring::ResidueNeighborIterator &) const –> bool

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__iadd__(self: pyrosetta.rosetta.core.scoring.DerivVectorPair, rhs: pyrosetta.rosetta.core.scoring.DerivVectorPair) → pyrosetta.rosetta.core.scoring.DerivVectorPair

C++: core::scoring::DerivVectorPair::operator+=(const class core::scoring::DerivVectorPair &) –> class core::scoring::DerivVectorPair &

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.DerivVectorPair) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.DerivVectorPair, arg0: pyrosetta.rosetta.core.scoring.DerivVectorPair) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.DipolarCoupling) -> None

doc

2. __init__(self: pyrosetta.rosetta.core.scoring.DipolarCoupling, filename: str) -> None
3. __init__(self: pyrosetta.rosetta.core.scoring.DipolarCoupling, arg0: pyrosetta.rosetta.core.scoring.DipolarCoupling) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.scoring.DipolarCoupling) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(self: pyrosetta.rosetta.core.scoring.EMapVector, src: pyrosetta.rosetta.core.scoring.EMapVector) → bool

== operator for comparing two energy maps element by element

C++: core::scoring::EMapVector::operator==(const class core::scoring::EMapVector &) const –> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

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

[] operator for getting a non-const reference to the energy for a ScoreType

C++: core::scoring::EMapVector::operator[](enum core::scoring::ScoreType) –> double &

__gt__

Return self>value.

__hash__

Return hash(self).

__iadd__(self: pyrosetta.rosetta.core.scoring.EMapVector, src: pyrosetta.rosetta.core.scoring.EMapVector) → None

+= operator, for summing energies

C++: core::scoring::EMapVector::operator+=(const class core::scoring::EMapVector &) –> void

__imul__(*args, **kwargs)

Overloaded function.

1. __imul__(self: pyrosetta.rosetta.core.scoring.EMapVector, scalar: float) -> None

*= operator, for performing multiplication of a vector by a scalar

C++: core::scoring::EMapVector::operator*=(double) –> void

2. __imul__(self: pyrosetta.rosetta.core.scoring.EMapVector, src: pyrosetta.rosetta.core.scoring.EMapVector) -> None

*= operator, for performing element-by-element multiplication of two vectors

C++: core::scoring::EMapVector::operator*=(const class core::scoring::EMapVector &) –> void

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.EMapVector) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.EMapVector, arg0: pyrosetta.rosetta.core.scoring.EMapVector) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__isub__(self: pyrosetta.rosetta.core.scoring.EMapVector, src: pyrosetta.rosetta.core.scoring.EMapVector) → None

-= operator, for subtracting energies

C++: core::scoring::EMapVector::operator-=(const class core::scoring::EMapVector &) –> void

__le__

Return self<=value.

__lt__

Return self<value.

__mul__(*args, **kwargs)

Overloaded function.

1. __mul__(self: pyrosetta.rosetta.core.scoring.EMapVector, scalar: float) -> pyrosetta.rosetta.core.scoring.EMapVector

• operator, for performing multiplication of a vector by a scalar

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

2. __mul__(self: pyrosetta.rosetta.core.scoring.EMapVector, src: pyrosetta.rosetta.core.scoring.EMapVector) -> pyrosetta.rosetta.core.scoring.EMapVector

• operator, for performing element-by-element multiplication of two vectors

C++: core::scoring::EMapVector::operator*(const class core::scoring::EMapVector &) –> class core::scoring::EMapVector

__ne__(self: pyrosetta.rosetta.core.scoring.EMapVector, src: pyrosetta.rosetta.core.scoring.EMapVector) → bool

!= operator for comparing two energy maps element by element

C++: core::scoring::EMapVector::operator!=(const class core::scoring::EMapVector &) const –> bool

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.scoring.EMapVector) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

accumulate(*args, **kwargs)

Overloaded function.

1. 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

2. 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.

1. 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

2. 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.

1. 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

2. 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.

1. 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

2. 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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.Energies) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.Energies, arg0: pyrosetta.rosetta.core.scoring.Energies) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.scoring.Energies) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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) → 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.

1. 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

2. 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.

1. same_type_as_me(self: pyrosetta.rosetta.core.scoring.Energies, other: pyrosetta.rosetta.core.scoring.Energies) -> bool
2. 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.

1. 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

2. 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

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

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

4. 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) → 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.

1. 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

2. 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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__getitem__(self: pyrosetta.rosetta.core.scoring.EnergyEdge, st: pyrosetta.rosetta.core.scoring.ScoreType) → float

Read the value stored on this edge for a particular score type.

C++: core::scoring::EnergyEdge::operator[](enum core::scoring::ScoreType) const –> double

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.EnergyEdge, owner: core::scoring::EnergyGraph, n1: int, n2: int) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.EnergyEdge, owner: core::scoring::EnergyGraph, example_edge: pyrosetta.rosetta.core.scoring.EnergyEdge) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add_to_energy_map(*args, **kwargs)

Overloaded function.

1. 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

2. 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.

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

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

2. 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.

1. 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

2. 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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.EnergyGraph, num_nodes: int) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.EnergyGraph) -> None
3. __init__(self: pyrosetta.rosetta.core.scoring.EnergyGraph, arg0: pyrosetta.rosetta.core.scoring.EnergyGraph) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

1. 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 *

2. 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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.EnergyNode, owner: pyrosetta.rosetta.utility.graph.Graph, index: int) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

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

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

2. 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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo, arg0: pyrosetta.rosetta.core.scoring.FACTSPoseInfo) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

1. update_enumeration_shell(self: pyrosetta.rosetta.core.scoring.FACTSPoseInfo, pose: pyrosetta.rosetta.core.pose.Pose) -> None
2. 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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.FACTSPotential) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

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

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

2. 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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, arg0: pyrosetta.rosetta.core.conformation.Residue, arg1: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo) -> None

doc

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

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

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

2. 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.

1. initialize(self: pyrosetta.rosetta.core.scoring.FACTSResidueInfo, rsd: pyrosetta.rosetta.core.conformation.Residue, restypeinfo: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo) -> None
2. 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.

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

2. 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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.FACTSRotamerSetInfo, arg0: pyrosetta.rosetta.core.scoring.FACTSRotamerSetInfo) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.FACTSRotamerSetInfo, rotamer_set: pyrosetta.rosetta.core.conformation.RotamerSetBase, rsdtypemap: pyrosetta.rosetta.core.scoring.FACTSRsdTypeMap) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeInfo) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.FACTSRsdTypeMap) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.GenBornPoseInfo) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.GenBornPoseInfo, arg0: pyrosetta.rosetta.core.scoring.GenBornPoseInfo) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.GenBornPotential) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.GenBornResidueInfo, rsd: pyrosetta.rosetta.core.conformation.Residue) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.GenBornResidueInfo, arg0: pyrosetta.rosetta.core.scoring.GenBornResidueInfo) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.GenBornRotamerSetInfo, arg0: pyrosetta.rosetta.core.scoring.GenBornRotamerSetInfo) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.GenBornRotamerSetInfo, rotamer_set: pyrosetta.rosetta.core.conformation.RotamerSetBase) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.Hairpin

Bases: pybind11_builtins.pybind11_object

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.Hairpin) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.Hairpin, s1_1: int, s1_2: int, s2_1: int, s2_2: int) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.scoring.Hairpin) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.Helices) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.Helices, total_residue: int) -> None
3. __init__(self: pyrosetta.rosetta.core.scoring.Helices, arg0: pyrosetta.rosetta.core.scoring.Helices) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.scoring.Helices) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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)

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.MembraneEmbed) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.MembraneEmbed, arg0: pyrosetta.rosetta.core.scoring.MembraneEmbed) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.MembranePotential) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.MembranePotential, arg0: pyrosetta.rosetta.core.scoring.MembranePotential) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

1. 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

2. 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.

1. 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

2. 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.

1. 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

2. 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.

1. 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

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed, arg0: pyrosetta.rosetta.core.scoring.Membrane_FAEmbed) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.Membrane_FAPotential) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.Membrane_FAPotential, arg0: pyrosetta.rosetta.core.scoring.Membrane_FAPotential) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.MinimizationEdge, owner: core::scoring::MinimizationGraph, n1: int, n2: int) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.MinimizationEdge, owner: core::scoring::MinimizationGraph, example_edge: pyrosetta.rosetta.core.scoring.MinimizationEdge) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

1. dweight(self: pyrosetta.rosetta.core.scoring.MinimizationEdge) -> float

C++: core::scoring::MinimizationEdge::dweight() const –> double

2. 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.

1. 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

2. 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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.MinimizationGraph, num_nodes: int) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.MinimizationGraph) -> None
3. __init__(self: pyrosetta.rosetta.core.scoring.MinimizationGraph, arg0: pyrosetta.rosetta.core.scoring.MinimizationGraph) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add_edge(*args, **kwargs)

Overloaded function.

1. 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 *

2. 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.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.MinimizationNode, owner: pyrosetta.rosetta.utility.graph.Graph, index: int) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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.

1. dweight(self: pyrosetta.rosetta.core.scoring.MinimizationNode) -> float

C++: core::scoring::MinimizationNode::dweight() const –> double

2. 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

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

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.MinimizationNode) → None

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

res_min_data(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → pyrosetta.rosetta.core.scoring.ResSingleMinimizationData

C++: core::scoring::MinimizationNode::res_min_data() –> class core::scoring::ResSingleMinimizationData &

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

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.MinimizationNode, rsd: pyrosetta.rosetta.core.conformation.Residue, residue_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: core::scoring::MinimizationNode::setup_for_derivatives(const class core::conformation::Residue &, class basic::datacache::BasicDataCache &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &) –> void

setup_for_minimizing(self: pyrosetta.rosetta.core.scoring.MinimizationNode, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, min_map: pyrosetta.rosetta.core.kinematics.MinimizerMapBase, res_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache) → None

C++: core::scoring::MinimizationNode::setup_for_minimizing(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, const class core::kinematics::MinimizerMapBase &, class basic::datacache::BasicDataCache &) –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.MinimizationNode, rsd: pyrosetta.rosetta.core.conformation.Residue, residue_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: core::scoring::MinimizationNode::setup_for_scoring(const class core::conformation::Residue &, class basic::datacache::BasicDataCache &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &) –> void

sfd_req_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::sfd_req_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> > > >

sfd_req_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::sfd_req_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> > > >

sfd_req_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::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.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::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_dm_req_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::sfs_dm_req_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> > > >

sfs_dm_req_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::sfs_dm_req_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> > > >

sfs_dm_req_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::sfs_dm_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_dm_req_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::sfs_dm_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_drs_req_enmeths_begin(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::EnergyMethod const> const*, std::vector<std::shared_ptr<core::scoring::methods::EnergyMethod const>, std::allocator<std::shared_ptr<core::scoring::methods::EnergyMethod const> > > >

C++: core::scoring::MinimizationNode::sfs_drs_req_enmeths_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::EnergyMethod> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::EnergyMethod>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::EnergyMethod> > > >

sfs_drs_req_enmeths_end(self: pyrosetta.rosetta.core.scoring.MinimizationNode) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::EnergyMethod const> const*, std::vector<std::shared_ptr<core::scoring::methods::EnergyMethod const>, std::allocator<std::shared_ptr<core::scoring::methods::EnergyMethod const> > > >

C++: core::scoring::MinimizationNode::sfs_drs_req_enmeths_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::EnergyMethod> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::EnergyMethod>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::EnergyMethod> > > >

update_active_enmeths_for_residue(self: pyrosetta.rosetta.core.scoring.MinimizationNode, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.EMapVector, domain_map_color: int) → None

C++: core::scoring::MinimizationNode::update_active_enmeths_for_residue(const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::EMapVector &, int) –> 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

weight(*args, **kwargs)

Overloaded function.

1. weight(self: pyrosetta.rosetta.core.scoring.MinimizationNode) -> float

C++: core::scoring::MinimizationNode::weight() const –> double

2. weight(self: pyrosetta.rosetta.core.scoring.MinimizationNode, setting: float) -> None

C++: core::scoring::MinimizationNode::weight(double) –> void

class pyrosetta.rosetta.core.scoring.MultipoleAxisType

Bases: pybind11_builtins.pybind11_object

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(*args, **kwargs)

Overloaded function.

1. __eq__(self: pyrosetta.rosetta.core.scoring.MultipoleAxisType, arg0: pyrosetta.rosetta.core.scoring.MultipoleAxisType) -> bool
2. __eq__(self: pyrosetta.rosetta.core.scoring.MultipoleAxisType, arg0: int) -> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__getstate__(self: pyrosetta.rosetta.core.scoring.MultipoleAxisType) → tuple

__gt__

Return self>value.

__hash__(self: pyrosetta.rosetta.core.scoring.MultipoleAxisType) → int

__init__(self: pyrosetta.rosetta.core.scoring.MultipoleAxisType, arg0: int) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__int__(self: pyrosetta.rosetta.core.scoring.MultipoleAxisType) → int

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(*args, **kwargs)

Overloaded function.

1. __ne__(self: pyrosetta.rosetta.core.scoring.MultipoleAxisType, arg0: pyrosetta.rosetta.core.scoring.MultipoleAxisType) -> bool
2. __ne__(self: pyrosetta.rosetta.core.scoring.MultipoleAxisType, arg0: int) -> bool

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__(self: pyrosetta.rosetta.core.scoring.MultipoleAxisType) → str

__setattr__

Implement setattr(self, name, value).

__setstate__(self: pyrosetta.rosetta.core.scoring.MultipoleAxisType, arg0: tuple) → None

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

class pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo, arg0: pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo, : pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo) → pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo

C++: core::scoring::MultipoleElecPoseInfo::operator=(const class core::scoring::MultipoleElecPoseInfo &) –> class core::scoring::MultipoleElecPoseInfo &

being_packed(self: pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo, seqpos: int) → bool

C++: core::scoring::MultipoleElecPoseInfo::being_packed(const unsigned long) const –> bool

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

C++: core::scoring::MultipoleElecPoseInfo::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.MultipoleElecPoseInfo, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

placeholder_info(self: pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo, seqpos: int) → pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo

C++: core::scoring::MultipoleElecPoseInfo::placeholder_info(const unsigned long) const –> const class core::scoring::MultipoleElecResidueInfo &

placeholder_residue(self: pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo, seqpos: int) → pyrosetta.rosetta.core.conformation.Residue

C++: core::scoring::MultipoleElecPoseInfo::placeholder_residue(const unsigned long) const –> const class core::conformation::Residue &

residue_info(self: pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo, i: int) → pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo

C++: core::scoring::MultipoleElecPoseInfo::residue_info(const unsigned long) –> class core::scoring::MultipoleElecResidueInfo &

set_placeholder(self: pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo, i: int, rsd: pyrosetta.rosetta.core.conformation.Residue, info: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) → None

C++: core::scoring::MultipoleElecPoseInfo::set_placeholder(const unsigned long, class std::shared_ptr<class core::conformation::Residue>, class std::shared_ptr<class core::scoring::MultipoleElecResidueInfo>) –> void

set_repack_list(self: pyrosetta.rosetta.core.scoring.MultipoleElecPoseInfo, repacking_residues: pyrosetta.rosetta.utility.vector1_bool) → None

C++: core::scoring::MultipoleElecPoseInfo::set_repack_list(const class utility::vector1<bool, class std::allocator<bool> > &) –> void

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

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

class pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

Efield_fixed(*args, **kwargs)

Overloaded function.

1. Efield_fixed(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleElecResidueInfo::Efield_fixed(const unsigned long) –> class numeric::xyzVector<double> &

2. Efield_fixed(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) -> pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t

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

Efield_induced(*args, **kwargs)

Overloaded function.

1. Efield_induced(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleElecResidueInfo::Efield_induced(const unsigned long) –> class numeric::xyzVector<double> &

2. Efield_induced(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) -> pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t

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

Efield_rf_fixed(*args, **kwargs)

Overloaded function.

1. Efield_rf_fixed(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleElecResidueInfo::Efield_rf_fixed(const unsigned long) –> class numeric::xyzVector<double> &

2. Efield_rf_fixed(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) -> pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t

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

Efield_rf_induced(*args, **kwargs)

Overloaded function.

1. Efield_rf_induced(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleElecResidueInfo::Efield_rf_induced(const unsigned long) –> class numeric::xyzVector<double> &

2. Efield_rf_induced(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) -> pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t

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

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, rsd: pyrosetta.rosetta.core.conformation.Residue) -> None
3. __init__(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, arg0: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, : pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) → pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo

C++: core::scoring::MultipoleElecResidueInfo::operator=(const class core::scoring::MultipoleElecResidueInfo &) –> class core::scoring::MultipoleElecResidueInfo &

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

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

const_my_group(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.utility.vector1_core_id_AtomID

C++: core::scoring::MultipoleElecResidueInfo::const_my_group(const unsigned long) const –> const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &

coord_frame_ref(*args, **kwargs)

Overloaded function.

1. coord_frame_ref(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) -> pyrosetta.rosetta.utility.vector1_core_id_AtomID

C++: core::scoring::MultipoleElecResidueInfo::coord_frame_ref() const –> const class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &

2. coord_frame_ref(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) -> pyrosetta.rosetta.core.id.AtomID

C++: core::scoring::MultipoleElecResidueInfo::coord_frame_ref(const unsigned long) const –> class core::id::AtomID

copy_clone(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) → pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo

C++: core::scoring::MultipoleElecResidueInfo::copy_clone() const –> class std::shared_ptr<class core::scoring::MultipoleElecResidueInfo>

dipole(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleElecResidueInfo::dipole(const unsigned long) const –> const class numeric::xyzVector<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>

induced_dipole(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleElecResidueInfo::induced_dipole(const unsigned long) const –> const class numeric::xyzVector<double> &

induced_rf_dipole(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleElecResidueInfo::induced_rf_dipole(const unsigned long) const –> const class numeric::xyzVector<double> &

initialize(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, rsd: pyrosetta.rosetta.core.conformation.Residue) → None

C++: core::scoring::MultipoleElecResidueInfo::initialize(const class core::conformation::Residue &) –> void

local_coord_matrix(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: core::scoring::MultipoleElecResidueInfo::local_coord_matrix(const unsigned long) –> class numeric::xyzMatrix<double> &

monopole(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → float

C++: core::scoring::MultipoleElecResidueInfo::monopole(const unsigned long) const –> double

mp_param(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm1: int) → core::scoring::MultipoleParameter

C++: core::scoring::MultipoleElecResidueInfo::mp_param(unsigned long) const –> const class std::shared_ptr<class core::scoring::MultipoleParameter> &

my_group(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.utility.vector1_core_id_AtomID

C++: core::scoring::MultipoleElecResidueInfo::my_group(const unsigned long) –> class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &

my_local_coord_frame(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.utility.vector1_core_id_AtomID

C++: core::scoring::MultipoleElecResidueInfo::my_local_coord_frame(const unsigned long) –> class utility::vector1<class core::id::AtomID, class std::allocator<class core::id::AtomID> > &

nonconst_dipole(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleElecResidueInfo::nonconst_dipole(const unsigned long) –> class numeric::xyzVector<double> &

nonconst_induced_dipole(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleElecResidueInfo::nonconst_induced_dipole(const unsigned long) –> class numeric::xyzVector<double> &

nonconst_induced_rf_dipole(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleElecResidueInfo::nonconst_induced_rf_dipole(const unsigned long) –> class numeric::xyzVector<double> &

nonconst_monopole(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → float

C++: core::scoring::MultipoleElecResidueInfo::nonconst_monopole(const unsigned long) –> double &

nonconst_mp_param(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm1: int) → core::scoring::MultipoleParameter

C++: core::scoring::MultipoleElecResidueInfo::nonconst_mp_param(unsigned long) –> class std::shared_ptr<class core::scoring::MultipoleParameter> &

nonconst_quadrupole(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: core::scoring::MultipoleElecResidueInfo::nonconst_quadrupole(const unsigned long) –> class numeric::xyzMatrix<double> &

nonconst_rKirkwood(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → float

C++: core::scoring::MultipoleElecResidueInfo::nonconst_rKirkwood(const unsigned long) –> double &

nonconst_rosetta_res_type(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) → str

C++: core::scoring::MultipoleElecResidueInfo::nonconst_rosetta_res_type() –> std::string &

nonconst_stored_induced_dipole(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleElecResidueInfo::nonconst_stored_induced_dipole(const unsigned long) –> class numeric::xyzVector<double> &

nonconst_stored_induced_rf_dipole(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleElecResidueInfo::nonconst_stored_induced_rf_dipole(const unsigned long) –> class numeric::xyzVector<double> &

quadrupole(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: core::scoring::MultipoleElecResidueInfo::quadrupole(const unsigned long) const –> const class numeric::xyzMatrix<double> &

rKirkwood(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → float

C++: core::scoring::MultipoleElecResidueInfo::rKirkwood(const unsigned long) const –> double

rosetta_res_type(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) → str

C++: core::scoring::MultipoleElecResidueInfo::rosetta_res_type() const –> const std::string &

set_coord_frame_ref(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int, in_val: pyrosetta.rosetta.core.id.AtomID) → None

C++: core::scoring::MultipoleElecResidueInfo::set_coord_frame_ref(const unsigned long, class core::id::AtomID) –> void

set_type(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int, in_val: int) → None

C++: core::scoring::MultipoleElecResidueInfo::set_type(const unsigned long, unsigned long) –> void

stored_induced_dipole(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleElecResidueInfo::stored_induced_dipole(const unsigned long) const –> const class numeric::xyzVector<double> &

stored_induced_rf_dipole(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::MultipoleElecResidueInfo::stored_induced_rf_dipole(const unsigned long) const –> const class numeric::xyzVector<double> &

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: core::scoring::MultipoleElecResidueInfo::type() const –> const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &

2. type(self: pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo, atm: int) -> int

C++: core::scoring::MultipoleElecResidueInfo::type(const unsigned long) const –> unsigned long

class pyrosetta.rosetta.core.scoring.MultipoleElecRotamerSetInfo

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.MultipoleElecRotamerSetInfo, arg0: pyrosetta.rosetta.core.scoring.MultipoleElecRotamerSetInfo) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.MultipoleElecRotamerSetInfo, rotamer_set: pyrosetta.rosetta.core.conformation.RotamerSetBase) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.MultipoleElecRotamerSetInfo, : pyrosetta.rosetta.core.scoring.MultipoleElecRotamerSetInfo) → pyrosetta.rosetta.core.scoring.MultipoleElecRotamerSetInfo

C++: core::scoring::MultipoleElecRotamerSetInfo::operator=(const class core::scoring::MultipoleElecRotamerSetInfo &) –> class core::scoring::MultipoleElecRotamerSetInfo &

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

C++: core::scoring::MultipoleElecRotamerSetInfo::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.MultipoleElecRotamerSetInfo, rotamer_set: pyrosetta.rosetta.core.conformation.RotamerSetBase) → None

dont forget to 0 the born_radii

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

residue_info(self: pyrosetta.rosetta.core.scoring.MultipoleElecRotamerSetInfo, i: int) → pyrosetta.rosetta.core.scoring.MultipoleElecResidueInfo

C++: core::scoring::MultipoleElecRotamerSetInfo::residue_info(const unsigned long) –> class core::scoring::MultipoleElecResidueInfo &

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

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

class pyrosetta.rosetta.core.scoring.NeighborList

Bases: pybind11_builtins.pybind11_object

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.NeighborList, domain_map: ObjexxFCL::FArray1D<int>, XX_cutoff: float, XH_cutoff: float, HH_cutoff: float) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.NeighborList, arg0: pyrosetta.rosetta.core.scoring.NeighborList) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

atom_neighbors(*args, **kwargs)

Overloaded function.

1. atom_neighbors(self: pyrosetta.rosetta.core.scoring.NeighborList, pos: int, atomno: int) -> pyrosetta.rosetta.utility.vector1_core_scoring_AtomNeighbor

C++: core::scoring::NeighborList::atom_neighbors(const int, const int) const –> const class utility::vector1<class core::scoring::AtomNeighbor, class std::allocator<class core::scoring::AtomNeighbor> > &

2. atom_neighbors(self: pyrosetta.rosetta.core.scoring.NeighborList, id: pyrosetta.rosetta.core.id.AtomID) -> pyrosetta.rosetta.utility.vector1_core_scoring_AtomNeighbor

C++: core::scoring::NeighborList::atom_neighbors(const class core::id::AtomID &) const –> const class utility::vector1<class core::scoring::AtomNeighbor, class std::allocator<class core::scoring::AtomNeighbor> > &

check_domain_map(self: pyrosetta.rosetta.core.scoring.NeighborList, domain_map_in: ObjexxFCL::FArray1D<int>) → None

C++: core::scoring::NeighborList::check_domain_map(const class ObjexxFCL::FArray1D<int> &) const –> void

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

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

clone(self: pyrosetta.rosetta.core.scoring.NeighborList) → pyrosetta.rosetta.core.scoring.NeighborList

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

disable_auto_update(self: pyrosetta.rosetta.core.scoring.NeighborList) → None

C++: core::scoring::NeighborList::disable_auto_update() –> void

domain_map(self: pyrosetta.rosetta.core.scoring.NeighborList) → ObjexxFCL::FArray1D<int>

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

intrares_upper_atom_neighbors(*args, **kwargs)

Overloaded function.

1. intrares_upper_atom_neighbors(self: pyrosetta.rosetta.core.scoring.NeighborList, pos: int, atomno: int) -> pyrosetta.rosetta.utility.vector1_core_scoring_AtomNeighbor

C++: core::scoring::NeighborList::intrares_upper_atom_neighbors(const int, const int) const –> const class utility::vector1<class core::scoring::AtomNeighbor, class std::allocator<class core::scoring::AtomNeighbor> > &

2. intrares_upper_atom_neighbors(self: pyrosetta.rosetta.core.scoring.NeighborList, id: pyrosetta.rosetta.core.id.AtomID) -> pyrosetta.rosetta.utility.vector1_core_scoring_AtomNeighbor

C++: core::scoring::NeighborList::intrares_upper_atom_neighbors(const class core::id::AtomID &) const –> const class utility::vector1<class core::scoring::AtomNeighbor, class std::allocator<class core::scoring::AtomNeighbor> > &

set_auto_update(self: pyrosetta.rosetta.core.scoring.NeighborList, move_tolerance: float) → None

C++: core::scoring::NeighborList::set_auto_update(double) –> void

upper_atom_neighbors(*args, **kwargs)

Overloaded function.

1. upper_atom_neighbors(self: pyrosetta.rosetta.core.scoring.NeighborList, pos: int, atomno: int) -> pyrosetta.rosetta.utility.vector1_core_scoring_AtomNeighbor

C++: core::scoring::NeighborList::upper_atom_neighbors(const int, const int) const –> const class utility::vector1<class core::scoring::AtomNeighbor, class std::allocator<class core::scoring::AtomNeighbor> > &

2. upper_atom_neighbors(self: pyrosetta.rosetta.core.scoring.NeighborList, id: pyrosetta.rosetta.core.id.AtomID) -> pyrosetta.rosetta.utility.vector1_core_scoring_AtomNeighbor

C++: core::scoring::NeighborList::upper_atom_neighbors(const class core::id::AtomID &) const –> const class utility::vector1<class core::scoring::AtomNeighbor, class std::allocator<class core::scoring::AtomNeighbor> > &

class pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer

Bases: pyrosetta.rosetta.core.scoring.LREnergyContainer

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer, fixed_res_idx: int, size_in: int, score_type_in: pyrosetta.rosetta.core.scoring.ScoreType) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

any_neighbors_for_residue(self: pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer, : int) → bool

C++: core::scoring::OneToAllEnergyContainer::any_neighbors_for_residue(int) const –> bool

any_upper_neighbors_for_residue(self: pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer, resid: int) → bool

C++: core::scoring::OneToAllEnergyContainer::any_upper_neighbors_for_residue(int) const –> bool

assign(self: pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer, : pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer) → pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer

C++: core::scoring::OneToAllEnergyContainer::operator=(const class core::scoring::OneToAllEnergyContainer &) –> class core::scoring::OneToAllEnergyContainer &

clone(self: pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer) → pyrosetta.rosetta.core.scoring.LREnergyContainer

C++: core::scoring::OneToAllEnergyContainer::clone() const –> class std::shared_ptr<class core::scoring::LREnergyContainer>

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

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

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

const_neighbor_iterator_end(self: pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

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

const_upper_neighbor_iterator_begin(self: pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

C++: core::scoring::OneToAllEnergyContainer::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.OneToAllEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

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

empty(self: pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer) → bool

C++: core::scoring::OneToAllEnergyContainer::empty() const –> bool

fixed(self: pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer) → int

C++: core::scoring::OneToAllEnergyContainer::fixed() const –> int

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

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

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

neighbor_iterator_end(self: pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

C++: core::scoring::OneToAllEnergyContainer::neighbor_iterator_end(int) –> class std::shared_ptr<class core::scoring::ResidueNeighborIterator>

set_num_nodes(self: pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer, size_in: int) → None

C++: core::scoring::OneToAllEnergyContainer::set_num_nodes(unsigned long) –> void

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

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

upper_neighbor_iterator_begin(self: pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

C++: core::scoring::OneToAllEnergyContainer::upper_neighbor_iterator_begin(int) –> class std::shared_ptr<class core::scoring::ResidueNeighborIterator>

upper_neighbor_iterator_end(self: pyrosetta.rosetta.core.scoring.OneToAllEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

C++: core::scoring::OneToAllEnergyContainer::upper_neighbor_iterator_end(int) –> class std::shared_ptr<class core::scoring::ResidueNeighborIterator>

class pyrosetta.rosetta.core.scoring.OneToAllNeighborConstIterator

Bases: pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborConstIterator, other: pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator) → bool

C++: core::scoring::OneToAllNeighborConstIterator::operator==(const class core::scoring::ResidueNeighborConstIterator &) const –> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborConstIterator, pos1_in: int, pos2_in: int, operating_on_pos1_in: bool, st: pyrosetta.rosetta.core.scoring.ScoreType, table_in: pyrosetta.rosetta.utility.vector1_double, computed_in: pyrosetta.rosetta.utility.vector1_bool) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborConstIterator, other: pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator) → bool

C++: core::scoring::OneToAllNeighborConstIterator::operator!=(const class core::scoring::ResidueNeighborConstIterator &) const –> bool

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

accumulate_energy(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborConstIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::OneToAllNeighborConstIterator::accumulate_energy(class core::scoring::EMapVector &) const –> void

assign(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborConstIterator, src: pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

C++: core::scoring::OneToAllNeighborConstIterator::operator=(const class core::scoring::ResidueNeighborConstIterator &) –> class core::scoring::ResidueNeighborConstIterator &

energy_computed(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborConstIterator) → bool

C++: core::scoring::OneToAllNeighborConstIterator::energy_computed() const –> bool

lower_neighbor_id(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborConstIterator) → int

C++: core::scoring::OneToAllNeighborConstIterator::lower_neighbor_id() const –> unsigned long

neighbor_id(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborConstIterator) → int

C++: core::scoring::OneToAllNeighborConstIterator::neighbor_id() const –> unsigned long

plus_plus(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborConstIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

C++: core::scoring::OneToAllNeighborConstIterator::operator++() –> const class core::scoring::ResidueNeighborConstIterator &

residue_iterated_on(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborConstIterator) → int

C++: core::scoring::OneToAllNeighborConstIterator::residue_iterated_on() const –> unsigned long

retrieve_energy(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborConstIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::OneToAllNeighborConstIterator::retrieve_energy(class core::scoring::EMapVector &) const –> void

upper_neighbor_id(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborConstIterator) → int

C++: core::scoring::OneToAllNeighborConstIterator::upper_neighbor_id() const –> unsigned long

class pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator

Bases: pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator, other: pyrosetta.rosetta.core.scoring.ResidueNeighborIterator) → bool

C++: core::scoring::OneToAllNeighborIterator::operator==(const class core::scoring::ResidueNeighborIterator &) const –> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator, pos1_in: int, pos2_in: int, operating_on_pos1_in: bool, st: pyrosetta.rosetta.core.scoring.ScoreType, table_in: pyrosetta.rosetta.utility.vector1_double, computed_in: pyrosetta.rosetta.utility.vector1_bool) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator, other: pyrosetta.rosetta.core.scoring.ResidueNeighborIterator) → bool

C++: core::scoring::OneToAllNeighborIterator::operator!=(const class core::scoring::ResidueNeighborIterator &) const –> bool

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

accumulate_energy(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::OneToAllNeighborIterator::accumulate_energy(class core::scoring::EMapVector &) const –> void

assign(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator, src: pyrosetta.rosetta.core.scoring.ResidueNeighborIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

C++: core::scoring::OneToAllNeighborIterator::operator=(const class core::scoring::ResidueNeighborIterator &) –> class core::scoring::ResidueNeighborIterator &

energy_computed(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator) → bool

C++: core::scoring::OneToAllNeighborIterator::energy_computed() const –> bool

lower_neighbor_id(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator) → int

C++: core::scoring::OneToAllNeighborIterator::lower_neighbor_id() const –> unsigned long

mark_energy_computed(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator) → None

C++: core::scoring::OneToAllNeighborIterator::mark_energy_computed() –> void

mark_energy_uncomputed(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator) → None

C++: core::scoring::OneToAllNeighborIterator::mark_energy_uncomputed() –> void

neighbor_id(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator) → int

C++: core::scoring::OneToAllNeighborIterator::neighbor_id() const –> unsigned long

plus_plus(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

C++: core::scoring::OneToAllNeighborIterator::operator++() –> const class core::scoring::ResidueNeighborIterator &

residue_iterated_on(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator) → int

C++: core::scoring::OneToAllNeighborIterator::residue_iterated_on() const –> unsigned long

retrieve_energy(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::OneToAllNeighborIterator::retrieve_energy(class core::scoring::EMapVector &) const –> void

save_energy(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::OneToAllNeighborIterator::save_energy(const class core::scoring::EMapVector &) –> void

upper_neighbor_id(self: pyrosetta.rosetta.core.scoring.OneToAllNeighborIterator) → int

C++: core::scoring::OneToAllNeighborIterator::upper_neighbor_id() const –> unsigned long

class pyrosetta.rosetta.core.scoring.PDatom

Bases: pybind11_builtins.pybind11_object

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.PDatom) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.PDatom, : pyrosetta.rosetta.core.scoring.PDatom) → pyrosetta.rosetta.core.scoring.PDatom

C++: core::scoring::PDatom::operator=(const class core::scoring::PDatom &) –> class core::scoring::PDatom &

atom(self: pyrosetta.rosetta.core.scoring.PDatom) → int

C++: core::scoring::PDatom::atom() const –> const unsigned long &

nonconst_atom(self: pyrosetta.rosetta.core.scoring.PDatom) → int

C++: core::scoring::PDatom::nonconst_atom() –> unsigned long &

nonconst_rad(self: pyrosetta.rosetta.core.scoring.PDatom) → float

C++: core::scoring::PDatom::nonconst_rad() –> double &

nonconst_rad2(self: pyrosetta.rosetta.core.scoring.PDatom) → float

C++: core::scoring::PDatom::nonconst_rad2() –> double &

nonconst_res(self: pyrosetta.rosetta.core.scoring.PDatom) → int

C++: core::scoring::PDatom::nonconst_res() –> unsigned long &

nonconst_xyz(self: pyrosetta.rosetta.core.scoring.PDatom) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::PDatom::nonconst_xyz() –> class numeric::xyzVector<double> &

rad(self: pyrosetta.rosetta.core.scoring.PDatom) → float

C++: core::scoring::PDatom::rad() const –> const double &

rad2(self: pyrosetta.rosetta.core.scoring.PDatom) → float

C++: core::scoring::PDatom::rad2() const –> const double &

res(self: pyrosetta.rosetta.core.scoring.PDatom) → int

C++: core::scoring::PDatom::res() const –> const unsigned long &

vertices(self: pyrosetta.rosetta.core.scoring.PDatom) → pyrosetta.rosetta.std.list_std_shared_ptr_core_scoring_PDvertex_std_allocator_std_shared_ptr_core_scoring_PDvertex_t

C++: core::scoring::PDatom::vertices() –> class std::list<class std::shared_ptr<class core::scoring::PDvertex>, class std::allocator<class std::shared_ptr<class core::scoring::PDvertex> > > &

xyz(self: pyrosetta.rosetta.core.scoring.PDatom) → pyrosetta.rosetta.numeric.xyzVector_double_t

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

class pyrosetta.rosetta.core.scoring.PQR

Bases: pybind11_builtins.pybind11_object

PQR

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.PQR, pose: pyrosetta.rosetta.core.pose.Pose, natoms: int, charged_residues: pyrosetta.rosetta.std.map_std_string_bool) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.PQR, : pyrosetta.rosetta.core.scoring.PQR) → pyrosetta.rosetta.core.scoring.PQR

C++: core::scoring::PQR::operator=(const class core::scoring::PQR &) –> class core::scoring::PQR &

get_natoms(self: pyrosetta.rosetta.core.scoring.PQR) → int

C++: core::scoring::PQR::get_natoms() –> int

class pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer

Bases: pyrosetta.rosetta.core.scoring.LREnergyContainer

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer, pose: pyrosetta.rosetta.core.pose.Pose, score_type_in: pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

any_neighbors_for_residue(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer, : int) → bool

C++: core::scoring::PolymerBondedEnergyContainer::any_neighbors_for_residue(int) const –> bool

any_upper_neighbors_for_residue(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer, : int) → bool

C++: core::scoring::PolymerBondedEnergyContainer::any_upper_neighbors_for_residue(int) const –> bool

assign(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer, : pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer) → pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer

C++: core::scoring::PolymerBondedEnergyContainer::operator=(const class core::scoring::PolymerBondedEnergyContainer &) –> class core::scoring::PolymerBondedEnergyContainer &

clone(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer) → pyrosetta.rosetta.core.scoring.LREnergyContainer

C++: core::scoring::PolymerBondedEnergyContainer::clone() const –> class std::shared_ptr<class core::scoring::LREnergyContainer>

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

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

const_neighbor_iterator_end(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

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

const_upper_neighbor_iterator_begin(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

C++: core::scoring::PolymerBondedEnergyContainer::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.PolymerBondedEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

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

empty(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer) → bool

C++: core::scoring::PolymerBondedEnergyContainer::empty() const –> bool

get_computed(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer, res1: int, res2: int) → bool

C++: core::scoring::PolymerBondedEnergyContainer::get_computed(unsigned long, unsigned long) const –> bool

get_energy(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer, res1: int, res2: int, scoreterm: int) → float

C++: core::scoring::PolymerBondedEnergyContainer::get_energy(unsigned long, unsigned long, unsigned long) const –> double

is_valid(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer, pose: pyrosetta.rosetta.core.pose.Pose) → bool

Is this PolymerBondedEnergyContainer properly set up for the pose?

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::PolymerBondedEnergyContainer::is_valid(const class core::pose::Pose &) const –> bool

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

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

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

neighbor_iterator_end(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

C++: core::scoring::PolymerBondedEnergyContainer::neighbor_iterator_end(int) –> class std::shared_ptr<class core::scoring::ResidueNeighborIterator>

score_types(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer) → pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

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

set_computed(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer, res1: int, res2: int, val: bool) → None

C++: core::scoring::PolymerBondedEnergyContainer::set_computed(unsigned long, unsigned long, bool) –> void

set_energy(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer, res1: int, res2: int, scoreterm: int, E: float) → None

C++: core::scoring::PolymerBondedEnergyContainer::set_energy(unsigned long, unsigned long, unsigned long, double) –> void

set_num_nodes(self: pyrosetta.rosetta.core.scoring.LREnergyContainer, : int) → None

C++: core::scoring::LREnergyContainer::set_num_nodes(unsigned long) –> void

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

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

upper_neighbor_iterator_begin(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

C++: core::scoring::PolymerBondedEnergyContainer::upper_neighbor_iterator_begin(int) –> class std::shared_ptr<class core::scoring::ResidueNeighborIterator>

upper_neighbor_iterator_end(self: pyrosetta.rosetta.core.scoring.PolymerBondedEnergyContainer, resid: int) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

C++: core::scoring::PolymerBondedEnergyContainer::upper_neighbor_iterator_end(int) –> class std::shared_ptr<class core::scoring::ResidueNeighborIterator>

class pyrosetta.rosetta.core.scoring.PolymerBondedNeighborConstIterator

Bases: pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborConstIterator, other: pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator) → bool

C++: core::scoring::PolymerBondedNeighborConstIterator::operator==(const class core::scoring::ResidueNeighborConstIterator &) const –> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborConstIterator, base_in: int, positions_in: pyrosetta.rosetta.utility.vector1_unsigned_long, parent: core::scoring::PolymerBondedEnergyContainer) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborConstIterator, other: pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator) → bool

C++: core::scoring::PolymerBondedNeighborConstIterator::operator!=(const class core::scoring::ResidueNeighborConstIterator &) const –> bool

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

accumulate_energy(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborConstIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::PolymerBondedNeighborConstIterator::accumulate_energy(class core::scoring::EMapVector &) const –> void

assign(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborConstIterator, src: pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

C++: core::scoring::PolymerBondedNeighborConstIterator::operator=(const class core::scoring::ResidueNeighborConstIterator &) –> class core::scoring::ResidueNeighborConstIterator &

energy_computed(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborConstIterator) → bool

C++: core::scoring::PolymerBondedNeighborConstIterator::energy_computed() const –> bool

lower_neighbor_id(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborConstIterator) → int

C++: core::scoring::PolymerBondedNeighborConstIterator::lower_neighbor_id() const –> unsigned long

neighbor_id(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborConstIterator) → int

C++: core::scoring::PolymerBondedNeighborConstIterator::neighbor_id() const –> unsigned long

plus_plus(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborConstIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborConstIterator

C++: core::scoring::PolymerBondedNeighborConstIterator::operator++() –> const class core::scoring::ResidueNeighborConstIterator &

residue_iterated_on(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborConstIterator) → int

C++: core::scoring::PolymerBondedNeighborConstIterator::residue_iterated_on() const –> unsigned long

retrieve_energy(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborConstIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::PolymerBondedNeighborConstIterator::retrieve_energy(class core::scoring::EMapVector &) const –> void

upper_neighbor_id(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborConstIterator) → int

C++: core::scoring::PolymerBondedNeighborConstIterator::upper_neighbor_id() const –> unsigned long

class pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator

Bases: pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator, other: pyrosetta.rosetta.core.scoring.ResidueNeighborIterator) → bool

C++: core::scoring::PolymerBondedNeighborIterator::operator==(const class core::scoring::ResidueNeighborIterator &) const –> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator, base_in: int, positions_in: pyrosetta.rosetta.utility.vector1_unsigned_long, parent: core::scoring::PolymerBondedEnergyContainer) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator, other: pyrosetta.rosetta.core.scoring.ResidueNeighborIterator) → bool

C++: core::scoring::PolymerBondedNeighborIterator::operator!=(const class core::scoring::ResidueNeighborIterator &) const –> bool

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

accumulate_energy(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::PolymerBondedNeighborIterator::accumulate_energy(class core::scoring::EMapVector &) const –> void

assign(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator, src: pyrosetta.rosetta.core.scoring.ResidueNeighborIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

C++: core::scoring::PolymerBondedNeighborIterator::operator=(const class core::scoring::ResidueNeighborIterator &) –> class core::scoring::ResidueNeighborIterator &

energy_computed(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator) → bool

C++: core::scoring::PolymerBondedNeighborIterator::energy_computed() const –> bool

lower_neighbor_id(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator) → int

C++: core::scoring::PolymerBondedNeighborIterator::lower_neighbor_id() const –> unsigned long

mark_energy_computed(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator) → None

C++: core::scoring::PolymerBondedNeighborIterator::mark_energy_computed() –> void

mark_energy_uncomputed(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator) → None

C++: core::scoring::PolymerBondedNeighborIterator::mark_energy_uncomputed() –> void

neighbor_id(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator) → int

C++: core::scoring::PolymerBondedNeighborIterator::neighbor_id() const –> unsigned long

plus_plus(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator) → pyrosetta.rosetta.core.scoring.ResidueNeighborIterator

C++: core::scoring::PolymerBondedNeighborIterator::operator++() –> const class core::scoring::ResidueNeighborIterator &

residue_iterated_on(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator) → int

C++: core::scoring::PolymerBondedNeighborIterator::residue_iterated_on() const –> unsigned long

retrieve_energy(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::PolymerBondedNeighborIterator::retrieve_energy(class core::scoring::EMapVector &) const –> void

save_energy(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::PolymerBondedNeighborIterator::save_energy(const class core::scoring::EMapVector &) –> void

upper_neighbor_id(self: pyrosetta.rosetta.core.scoring.PolymerBondedNeighborIterator) → int

C++: core::scoring::PolymerBondedNeighborIterator::upper_neighbor_id() const –> unsigned long

class pyrosetta.rosetta.core.scoring.Predicate

Bases: pybind11_builtins.pybind11_object

__call__(self: pyrosetta.rosetta.core.scoring.Predicate, pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

C++: core::scoring::Predicate::operator()(const class core::pose::Pose &, const class core::pose::Pose &, unsigned long, unsigned long) const –> bool

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.Predicate) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.Predicate, arg0: pyrosetta.rosetta.core.scoring.Predicate) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.Predicate, : pyrosetta.rosetta.core.scoring.Predicate) → pyrosetta.rosetta.core.scoring.Predicate

C++: core::scoring::Predicate::operator=(const class core::scoring::Predicate &) –> class core::scoring::Predicate &

class pyrosetta.rosetta.core.scoring.RDC

Bases: pybind11_builtins.pybind11_object

Dconst(self: pyrosetta.rosetta.core.scoring.RDC) → float

C++: core::scoring::RDC::Dconst() const –> double

Jcomputed(self: pyrosetta.rosetta.core.scoring.RDC) → float

C++: core::scoring::RDC::Jcomputed() –> double &

Jdipolar(self: pyrosetta.rosetta.core.scoring.RDC) → float

C++: core::scoring::RDC::Jdipolar() const –> double

Reduced_Jdipolar(self: pyrosetta.rosetta.core.scoring.RDC) → float

C++: core::scoring::RDC::Reduced_Jdipolar() const –> double

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.RDC) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.RDC, arg0: int, arg1: str, arg2: int, arg3: str, arg4: float) -> None

doc

3. __init__(self: pyrosetta.rosetta.core.scoring.RDC, arg0: int, arg1: str, arg2: int, arg3: str, arg4: float, arg5: float) -> None

doc

4. __init__(self: pyrosetta.rosetta.core.scoring.RDC, res1: int, atom1: str, res2: int, atom2: str, Jdipolar: float, weight: float, expid: int) -> None
5. __init__(self: pyrosetta.rosetta.core.scoring.RDC, arg0: pyrosetta.rosetta.core.scoring.RDC) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.scoring.RDC) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.RDC, : pyrosetta.rosetta.core.scoring.RDC) → pyrosetta.rosetta.core.scoring.RDC

C++: core::scoring::RDC::operator=(const class core::scoring::RDC &) –> class core::scoring::RDC &

atom1(self: pyrosetta.rosetta.core.scoring.RDC) → str

C++: core::scoring::RDC::atom1() const –> const std::string &

atom2(self: pyrosetta.rosetta.core.scoring.RDC) → str

C++: core::scoring::RDC::atom2() const –> const std::string &

expid(self: pyrosetta.rosetta.core.scoring.RDC) → int

C++: core::scoring::RDC::expid() const –> unsigned long

fij(self: pyrosetta.rosetta.core.scoring.RDC) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::RDC::fij() const –> class numeric::xyzVector<double>

fixed_dist(self: pyrosetta.rosetta.core.scoring.RDC) → float

C++: core::scoring::RDC::fixed_dist() const –> double

get_RDC_data_type(self: pyrosetta.rosetta.core.scoring.RDC, atom1: str, atom2: str) → pyrosetta.rosetta.core.scoring.RDC_TYPE

which type of RDC pairing are we dealing with ?

C++: core::scoring::RDC::get_RDC_data_type(const class std::basic_string<char> &, const class std::basic_string<char> &) –> enum core::scoring::RDC::RDC_TYPE

res1(self: pyrosetta.rosetta.core.scoring.RDC) → int

C++: core::scoring::RDC::res1() const –> unsigned long

res2(self: pyrosetta.rosetta.core.scoring.RDC) → int

C++: core::scoring::RDC::res2() const –> unsigned long

show(self: pyrosetta.rosetta.core.scoring.RDC, : pyrosetta.rosetta.std.ostream) → None

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

type(self: pyrosetta.rosetta.core.scoring.RDC) → pyrosetta.rosetta.core.scoring.RDC_TYPE

C++: core::scoring::RDC::type() const –> enum core::scoring::RDC::RDC_TYPE

weight(*args, **kwargs)

Overloaded function.

1. weight(self: pyrosetta.rosetta.core.scoring.RDC) -> float

C++: core::scoring::RDC::weight() const –> double

2. weight(self: pyrosetta.rosetta.core.scoring.RDC, w_in: float) -> None

C++: core::scoring::RDC::weight(double) –> void

class pyrosetta.rosetta.core.scoring.RDC_Rohl

Bases: pybind11_builtins.pybind11_object

Jdipolar(self: pyrosetta.rosetta.core.scoring.RDC_Rohl) → float

C++: core::scoring::RDC_Rohl::Jdipolar() const –> double

Reduced_Jdipolar(self: pyrosetta.rosetta.core.scoring.RDC_Rohl) → float

C++: core::scoring::RDC_Rohl::Reduced_Jdipolar() const –> double

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.RDC_Rohl) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.RDC_Rohl, arg0: int, arg1: int, arg2: float) -> None

doc

3. __init__(self: pyrosetta.rosetta.core.scoring.RDC_Rohl, type: int, res: int, Jdipolar: float, weight: float) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

fixed_dist(self: pyrosetta.rosetta.core.scoring.RDC_Rohl) → float

C++: core::scoring::RDC_Rohl::fixed_dist() const –> double

invDcnst(self: pyrosetta.rosetta.core.scoring.RDC_Rohl) → float

C++: core::scoring::RDC_Rohl::invDcnst() const –> double

res(self: pyrosetta.rosetta.core.scoring.RDC_Rohl) → int

C++: core::scoring::RDC_Rohl::res() const –> unsigned long

type(self: pyrosetta.rosetta.core.scoring.RDC_Rohl) → int

C++: core::scoring::RDC_Rohl::type() const –> unsigned long

weight(*args, **kwargs)

Overloaded function.

1. weight(self: pyrosetta.rosetta.core.scoring.RDC_Rohl) -> float

C++: core::scoring::RDC_Rohl::weight() const –> double

2. weight(self: pyrosetta.rosetta.core.scoring.RDC_Rohl, w_in: float) -> None

C++: core::scoring::RDC_Rohl::weight(double) –> void

class pyrosetta.rosetta.core.scoring.ResRangePredicate

Bases: pyrosetta.rosetta.core.scoring.Predicate

__call__(self: pyrosetta.rosetta.core.scoring.ResRangePredicate, pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

C++: core::scoring::ResRangePredicate::operator()(const class core::pose::Pose &, const class core::pose::Pose &, unsigned long, unsigned long) const –> bool

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.ResRangePredicate, start: int, end: int, predicate: pyrosetta.rosetta.core.scoring.Predicate) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.ResRangePredicate, : pyrosetta.rosetta.core.scoring.ResRangePredicate) → pyrosetta.rosetta.core.scoring.ResRangePredicate

C++: core::scoring::ResRangePredicate::operator=(const class core::scoring::ResRangePredicate &) –> class core::scoring::ResRangePredicate &

class pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

ResidualDipolarCouplings are mainly handled by this class

related classed: RDC — a single line in an RDC file - representing a single dipolar coupling

ResidualDipolarCouplingEnergy – an energy method which triggers computations handled by this class.

Q(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling) → float

return the Q value ( cornilescu ) — only valid after compute_dipscore

C++: core::scoring::ResidualDipolarCoupling::Q() const –> double

R(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling) → float

return the R value ( M Clore ) — only valid after compute_dipscore

C++: core::scoring::ResidualDipolarCoupling::R() const –> double

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling) -> None

doc

2. __init__(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, filename: str) -> None
3. __init__(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, data_in: pyrosetta.rosetta.utility.vector1_core_scoring_RDC) -> None
4. __init__(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, arg0: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, other: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling) → pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling

C++: core::scoring::ResidualDipolarCoupling::operator=(const class core::scoring::ResidualDipolarCoupling &) –> class core::scoring::ResidualDipolarCoupling &

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

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

compute_dipscore(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, pose: pyrosetta.rosetta.core.pose.Pose) → float

compute dipolar score for given pose

will set alignment tensor and force-fields in RDC

C++: core::scoring::ResidualDipolarCoupling::compute_dipscore(const class core::pose::Pose &) –> double

compute_dipscore_nls(*args, **kwargs)

Overloaded function.

1. compute_dipscore_nls(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, pose: pyrosetta.rosetta.core.pose.Pose) -> float

fit rdc using RDC data

C++: core::scoring::ResidualDipolarCoupling::compute_dipscore_nls(const class core::pose::Pose &) –> double

2. compute_dipscore_nls(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, pose: pyrosetta.rosetta.core.pose.Pose, tensorDa: pyrosetta.rosetta.utility.vector1_double, tensorR: pyrosetta.rosetta.utility.vector1_double) -> float

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

compute_dipscore_nlsDa(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, pose: pyrosetta.rosetta.core.pose.Pose, tensorDa: pyrosetta.rosetta.utility.vector1_double) → float

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

compute_dipscore_nlsDaR(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, pose: pyrosetta.rosetta.core.pose.Pose, tensorDa: pyrosetta.rosetta.utility.vector1_double, tensorR: pyrosetta.rosetta.utility.vector1_double) → float

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

compute_dipscore_nlsR(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, pose: pyrosetta.rosetta.core.pose.Pose, tensorR: pyrosetta.rosetta.utility.vector1_double) → float

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

compute_tensor_stats(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling) → None

C++: core::scoring::ResidualDipolarCoupling::compute_tensor_stats() –> void

do_correct_NH(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, it: __gnu_cxx::__normal_iterator<core::scoring::RDC const*, std::vector<core::scoring::RDC, std::allocator<core::scoring::RDC> > >, r: pyrosetta.rosetta.numeric.xyzVector_double_t, r2: float, invr: float) → None

C++: core::scoring::ResidualDipolarCoupling::do_correct_NH(class __gnu_cxx::__normal_iterator<const class core::scoring::RDC *, class std::vector<class core::scoring::RDC, class std::allocator<class core::scoring::RDC> > >, class numeric::xyzVector<double> &, double &, double &) –> void

get_RDC_data(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling) → pyrosetta.rosetta.utility.vector1_core_scoring_RDC

get the raw RDC data

C++: core::scoring::ResidualDipolarCoupling::get_RDC_data() const –> const class utility::vector1<class core::scoring::RDC, class std::allocator<class core::scoring::RDC> > &

get_al_tensor_max_z(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, ex: int) → float

C++: core::scoring::ResidualDipolarCoupling::get_al_tensor_max_z(unsigned long) const –> double

get_al_tensor_trace(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, ex: int) → float

C++: core::scoring::ResidualDipolarCoupling::get_al_tensor_trace(unsigned long) const –> double

get_n_alignments(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling) → int

C++: core::scoring::ResidualDipolarCoupling::get_n_alignments() const –> unsigned long

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>

iterate_tensor_weights(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, pose: pyrosetta.rosetta.core.pose.Pose, sigma2: float, tolerance: float, reset: bool) → float

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

preprocess_data(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling) → None

fill internal buffers… call always when RDC lines change.

C++: core::scoring::ResidualDipolarCoupling::preprocess_data() –> void

read_RDC_file(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling) → None

read RDC data from file

C++: core::scoring::ResidualDipolarCoupling::read_RDC_file() –> void

release_buffers(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling) → None

free memory of buffers

C++: core::scoring::ResidualDipolarCoupling::release_buffers() –> void

reserve_buffers(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling) → None

get memory for buffers

C++: core::scoring::ResidualDipolarCoupling::reserve_buffers() –> void

show(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, : pyrosetta.rosetta.std.ostream) → None

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

show_rdc_values(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, : pyrosetta.rosetta.std.ostream, ex: int) → None

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

show_tensor_matrix(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, : pyrosetta.rosetta.std.ostream, ex: int) → None

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

show_tensor_stats(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, : pyrosetta.rosetta.std.ostream, ex: int) → None

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

show_tensor_stats_nls(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling, : pyrosetta.rosetta.std.ostream, ex: int, par: float) → None

C++: core::scoring::ResidualDipolarCoupling::show_tensor_stats_nls(class std::basic_ostream<char> &, unsigned long, const double *) const –> void

tensor(self: pyrosetta.rosetta.core.scoring.ResidualDipolarCoupling) → pyrosetta.rosetta.utility.vector0_utility_fixedsizearray0_utility_fixedsizearray0_double_3_3_t

return tensor of certain experiment… exp_id starts at 1

C++: core::scoring::ResidualDipolarCoupling::tensor() –> class utility::vector0<class utility::fixedsizearray0<class utility::fixedsizearray0<double, 3>, 3>, class std::allocator<class utility::fixedsizearray0<class utility::fixedsizearray0<double, 3>, 3> > > &

class pyrosetta.rosetta.core.scoring.SS_Info

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.SS_Info, arg0: pyrosetta.rosetta.core.scoring.SS_Info) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.SS_Info) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.SS_Info, : pyrosetta.rosetta.core.scoring.SS_Info) → pyrosetta.rosetta.core.scoring.SS_Info

C++: core::scoring::SS_Info::operator=(const class core::scoring::SS_Info &) –> class core::scoring::SS_Info &

bb_pos(self: pyrosetta.rosetta.core.scoring.SS_Info) → pyrosetta.rosetta.core.scoring.BB_Pos

C++: core::scoring::SS_Info::bb_pos() –> class core::scoring::BB_Pos &

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

C++: core::scoring::SS_Info::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>

helices(self: pyrosetta.rosetta.core.scoring.SS_Info) → pyrosetta.rosetta.core.scoring.Helices

C++: core::scoring::SS_Info::helices() –> struct core::scoring::Helices &

resize(self: pyrosetta.rosetta.core.scoring.SS_Info, nres: int) → None

C++: core::scoring::SS_Info::resize(const int) –> void

strands(self: pyrosetta.rosetta.core.scoring.SS_Info) → pyrosetta.rosetta.core.scoring.Strands

C++: core::scoring::SS_Info::strands() –> struct core::scoring::Strands &

class pyrosetta.rosetta.core.scoring.SS_Killhairpins_Info

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.SS_Killhairpins_Info) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.SS_Killhairpins_Info, arg0: pyrosetta.rosetta.core.scoring.SS_Killhairpins_Info) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.SS_Killhairpins_Info, : pyrosetta.rosetta.core.scoring.SS_Killhairpins_Info) → pyrosetta.rosetta.core.scoring.SS_Killhairpins_Info

C++: core::scoring::SS_Killhairpins_Info::operator=(const class core::scoring::SS_Killhairpins_Info &) –> class core::scoring::SS_Killhairpins_Info &

check_hairpin(self: pyrosetta.rosetta.core.scoring.SS_Killhairpins_Info, strand1_res: int, strand2_res: int) → bool

C++: core::scoring::SS_Killhairpins_Info::check_hairpin(const unsigned long &, const unsigned long &) –> bool

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

C++: core::scoring::SS_Killhairpins_Info::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>

hairpins(self: pyrosetta.rosetta.core.scoring.SS_Killhairpins_Info) → pyrosetta.rosetta.core.scoring.Hairpins

C++: core::scoring::SS_Killhairpins_Info::hairpins() –> struct core::scoring::Hairpins &

kill_antiparallel(self: pyrosetta.rosetta.core.scoring.SS_Killhairpins_Info) → bool

C++: core::scoring::SS_Killhairpins_Info::kill_antiparallel() const –> bool

kill_parallel(self: pyrosetta.rosetta.core.scoring.SS_Killhairpins_Info) → bool

C++: core::scoring::SS_Killhairpins_Info::kill_parallel() const –> bool

setup_from_kill_hairpins_file(self: pyrosetta.rosetta.core.scoring.SS_Killhairpins_Info, input_file: pyrosetta.rosetta.utility.io.izstream) → None

C++: core::scoring::SS_Killhairpins_Info::setup_from_kill_hairpins_file(class utility::io::izstream &) –> void

setup_from_psipred(self: pyrosetta.rosetta.core.scoring.SS_Killhairpins_Info, input_file: pyrosetta.rosetta.utility.io.izstream) → None

C++: core::scoring::SS_Killhairpins_Info::setup_from_psipred(class utility::io::izstream &) –> void

setup_killhairpins(self: pyrosetta.rosetta.core.scoring.SS_Killhairpins_Info) → None

C++: core::scoring::SS_Killhairpins_Info::setup_killhairpins() –> void

class pyrosetta.rosetta.core.scoring.ScoreFunction

Bases: pybind11_builtins.pybind11_object

This object defines a ScoreFunction, it contains methods for calculating the various scoring components (called ScoreType’s) used in Rosetta. It also contains weights that are applied to each of those components. Only scoring components with non-zero weights are calculated.

__call__(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) → float

Scores the given <pose> using this ScoreFunction. Alters the Energies object within <pose>, but does not alter this ScoreFunction

C++: core::scoring::ScoreFunction::operator()(class core::pose::Pose &) const –> double

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__getitem__(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.rosetta.core.scoring.ScoreType) → float

Returns the weight of the ScoreType <t>

example(s):

scorefxn[fa_sol]

See also:

ScoreFunction ScoreFunction.get_weight ScoreFunction.set_weight ScoreFunction.weights ScoreType create_score_function name_from_score_type score_type_from_name

C++: core::scoring::ScoreFunction::operator[](const enum core::scoring::ScoreType &) const –> double

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.ScoreFunction, options: pyrosetta.rosetta.utility.options.OptionCollection) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

_add_weights_from_file(*args, **kwargs)

Overloaded function.

1. _add_weights_from_file(self: pyrosetta.rosetta.core.scoring.ScoreFunction, filename: str) -> None
2. _add_weights_from_file(self: pyrosetta.rosetta.core.scoring.ScoreFunction, filename: str, patch: bool) -> None

Initializes this ScoreFunction from the given <filename>

no lookup in database directory

C++: core::scoring::ScoreFunction::_add_weights_from_file(const class std::basic_string<char> &, bool) –> void

_add_weights_from_stream(*args, **kwargs)

Overloaded function.

1. _add_weights_from_stream(self: pyrosetta.rosetta.core.scoring.ScoreFunction, data: pyrosetta.rosetta.std.istream) -> None
2. _add_weights_from_stream(self: pyrosetta.rosetta.core.scoring.ScoreFunction, data: pyrosetta.rosetta.std.istream, patch: bool) -> None
3. _add_weights_from_stream(self: pyrosetta.rosetta.core.scoring.ScoreFunction, data: pyrosetta.rosetta.std.istream, patch: bool, filename: str) -> None

C++: core::scoring::ScoreFunction::_add_weights_from_stream(class std::basic_istream<char> &, bool, const class std::basic_string<char> &) –> void

add_extra_method(*args, **kwargs)

Overloaded function.

1. add_extra_method(self: pyrosetta.rosetta.core.scoring.ScoreFunction, new_type: pyrosetta.rosetta.core.scoring.ScoreType, new_weight: float, new_method: core::scoring::methods::EnergyMethod) -> None

Adds a scoring method that is not necessarily included in

the core library

C++: core::scoring::ScoreFunction::add_extra_method(const enum core::scoring::ScoreType &, const double, const class core::scoring::methods::EnergyMethod &) –> void

2. add_extra_method(self: pyrosetta.rosetta.core.scoring.ScoreFunction, new_weights: pyrosetta.rosetta.std.map_core_scoring_ScoreType_double, new_method: core::scoring::methods::EnergyMethod) -> None

Adds a scoring method that is not necessarily included in

the core library

C++: core::scoring::ScoreFunction::add_extra_method(const class std::map<enum core::scoring::ScoreType, double, struct std::less<enum core::scoring::ScoreType>, class std::allocator<struct std::pair<const enum core::scoring::ScoreType, double> > > &, const class core::scoring::methods::EnergyMethod &) –> void

add_to_weight(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.rosetta.core.scoring.ScoreType, increment: float) → None

Increments the weight for ScoreType <t> by <setting>

example(s):

scorefxn.add_to_weight(fa_sol,.5)

See also:

ScoreFunction ScoreFunction.get_weight ScoreFunction.set_weight ScoreType name_from_score_type score_type_from_name

C++: core::scoring::ScoreFunction::add_to_weight(const enum core::scoring::ScoreType &, const double &) –> void

add_weights_from_file(self: pyrosetta.rosetta.core.scoring.ScoreFunction, filename: str) → None

Initializes this ScoreFunction from the given <filename>

C++: core::scoring::ScoreFunction::add_weights_from_file(const class std::basic_string<char> &) –> void

all_energies_begin(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::EnergyMethod const> const*, std::vector<std::shared_ptr<core::scoring::methods::EnergyMethod const>, std::allocator<std::shared_ptr<core::scoring::methods::EnergyMethod const> > > >

C++: core::scoring::ScoreFunction::all_energies_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::EnergyMethod> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::EnergyMethod>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::EnergyMethod> > > >

all_energies_end(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::EnergyMethod const> const*, std::vector<std::shared_ptr<core::scoring::methods::EnergyMethod const>, std::allocator<std::shared_ptr<core::scoring::methods::EnergyMethod const> > > >

C++: core::scoring::ScoreFunction::all_energies_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::EnergyMethod> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::EnergyMethod>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::EnergyMethod> > > >

all_methods(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_core_scoring_methods_EnergyMethod_t

C++: core::scoring::ScoreFunction::all_methods() const –> const class utility::vector1<class std::shared_ptr<const class core::scoring::methods::EnergyMethod>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::EnergyMethod> > > &

any_lr_residue_pair_energy(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, res1: int, res2: int) → bool

C++: core::scoring::ScoreFunction::any_lr_residue_pair_energy(const class core::pose::Pose &, unsigned long, unsigned long) const –> bool

apply_patch_from_file(self: pyrosetta.rosetta.core.scoring.ScoreFunction, filename: str) → None

Applies a patch from the given <filename>

C++: core::scoring::ScoreFunction::apply_patch_from_file(const class std::basic_string<char> &) –> void

are_they_neighbors(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, pos1: int, pos2: int) → bool

Returns true if the <pose> positions <pos1> and <pos2>

are neighbors

C++: core::scoring::ScoreFunction::are_they_neighbors(const class core::pose::Pose &, const unsigned long, const unsigned long) const –> bool

assign(self: pyrosetta.rosetta.core.scoring.ScoreFunction, src: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

NOT FOR GENERAL USE

Copy the information about src into the current score function. There are deep interactions with subclasses, (the subclass information doesn’t necessarily get copied) so this is primarily for advanced scorefunction manipulation. Normal usage should just use clone() and replace the OP.

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

bump_check_backbone(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Scores the sidechain from <pose> Residue <rsd1> against the

backbone of Residue <rsd2>

C++: core::scoring::ScoreFunction::bump_check_backbone(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

bump_check_full(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::ScoreFunction::bump_check_full(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

cd_1b_types(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

convenience access to all cd 1b score types

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

cd_2b_begin(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextDependentTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextDependentTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextDependentTwoBodyEnergy> > > >

C++: core::scoring::ScoreFunction::cd_2b_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextDependentTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextDependentTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextDependentTwoBodyEnergy> > > >

cd_2b_end(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextDependentTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextDependentTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextDependentTwoBodyEnergy> > > >

C++: core::scoring::ScoreFunction::cd_2b_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextDependentTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextDependentTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextDependentTwoBodyEnergy> > > >

cd_2b_intrares_begin(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> > > >

C++: core::scoring::ScoreFunction::cd_2b_intrares_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> > > >

cd_2b_intrares_end(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> > > >

C++: core::scoring::ScoreFunction::cd_2b_intrares_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> > > >

cd_2b_types(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

convenience access to all cd 2b score types

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

cd_lr_2b_methods_begin(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextDependentLRTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextDependentLRTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextDependentLRTwoBodyEnergy> > > >

C++: core::scoring::ScoreFunction::cd_lr_2b_methods_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextDependentLRTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextDependentLRTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextDependentLRTwoBodyEnergy> > > >

cd_lr_2b_methods_end(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextDependentLRTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextDependentLRTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextDependentLRTwoBodyEnergy> > > >

C++: core::scoring::ScoreFunction::cd_lr_2b_methods_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextDependentLRTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextDependentLRTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextDependentLRTwoBodyEnergy> > > >

cd_lr_2b_types(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

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

check_methods_in_right_order(self: pyrosetta.rosetta.core.scoring.ScoreFunction, score_type_in_first_method: pyrosetta.rosetta.core.scoring.ScoreType, score_type_in_second_method: pyrosetta.rosetta.core.scoring.ScoreType) → bool

check order of methods

C++: core::scoring::ScoreFunction::check_methods_in_right_order(const enum core::scoring::ScoreType &, const enum core::scoring::ScoreType &) const –> bool

ci_1b_types(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

convenience access to all ci 1b score types

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

ci_2b_begin(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextIndependentTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextIndependentTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextIndependentTwoBodyEnergy> > > >

C++: core::scoring::ScoreFunction::ci_2b_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextIndependentTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextIndependentTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextIndependentTwoBodyEnergy> > > >

ci_2b_end(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextIndependentTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextIndependentTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextIndependentTwoBodyEnergy> > > >

C++: core::scoring::ScoreFunction::ci_2b_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextIndependentTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextIndependentTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextIndependentTwoBodyEnergy> > > >

ci_2b_intrares_begin(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> > > >

C++: core::scoring::ScoreFunction::ci_2b_intrares_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> > > >

ci_2b_intrares_end(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::TwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::TwoBodyEnergy> > > >

C++: core::scoring::ScoreFunction::ci_2b_intrares_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::TwoBodyEnergy> > > >

ci_2b_types(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

convenience access to all ci 2b score types

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

ci_lr_2b_methods_begin(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextIndependentLRTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextIndependentLRTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextIndependentLRTwoBodyEnergy> > > >

C++: core::scoring::ScoreFunction::ci_lr_2b_methods_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextIndependentLRTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextIndependentLRTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextIndependentLRTwoBodyEnergy> > > >

ci_lr_2b_methods_end(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::ContextIndependentLRTwoBodyEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::ContextIndependentLRTwoBodyEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::ContextIndependentLRTwoBodyEnergy> > > >

C++: core::scoring::ScoreFunction::ci_lr_2b_methods_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::ContextIndependentLRTwoBodyEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::ContextIndependentLRTwoBodyEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::ContextIndependentLRTwoBodyEnergy> > > >

ci_lr_2b_types(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

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

clone(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → pyrosetta.rosetta.core.scoring.ScoreFunction

Create a copy of the scorefunction

Virtual to keep subclass information.

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

clone_as_base_class(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → pyrosetta.rosetta.core.scoring.ScoreFunction

If you want to discard subclass information, the following function is availible

C++: core::scoring::ScoreFunction::clone_as_base_class() const –> class std::shared_ptr<class core::scoring::ScoreFunction>

energy_method_options(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → core::scoring::methods::EnergyMethodOptions

Returns the EnergyMethodOptions object contained in this

ScoreFunction (const access)

C++: core::scoring::ScoreFunction::energy_method_options() const –> const class core::scoring::methods::EnergyMethodOptions &

eval_cd_1b(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Accumulates the unweighted one body energies of all context

dependent one body energies for <pose> Residue <rsd> into EnergyMap <emap>

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::eval_cd_1b(const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_cd_2b(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Accumulate the unweighted short range context dependent two body

interaction energies of <pose> between Residue <rsd1> and Residue <rsd2> into EnergyMap <emap>

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::eval_cd_2b(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_cd_2b_bb_bb(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Accumulates the unweighted short ranged context dependent two body

interaction energies of <pose> between the backbones of Residue <rsd1> and <rsd2> into EnergyMap <emap>

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::eval_cd_2b_bb_bb(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_cd_2b_bb_sc(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Accumulates the unweighted short ranged context dependent two body

interaction energies of <pose> between the backbone of Residue <rsd1> and the sidechain of Residue <rsd2> into EnergyMap <emap>

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::eval_cd_2b_bb_sc(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_cd_2b_sc_sc(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Accumulates the unweighted short ranged context dependent two body

interaction energies of <pose> between the sidechains of Residue <rsd1> and Residue <rsd2> into EnergyMap <emap>

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::eval_cd_2b_sc_sc(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_cd_intrares_energy(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Accumulates the unweighted intra-residue one body energies for all

context dependent two body terms that define intra-residue energies of <pose> Residue <rsd> into EnergyMap <emap>

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::eval_cd_intrares_energy(const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_ci_1b(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::ScoreFunction::eval_ci_1b(const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_ci_2b(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Accumulates the unweighted context independent two body

interaction energies of <pose> between Residue <rsd1> and Residue <rsd2> into EnergyMap <emap>

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::eval_ci_2b(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_ci_2b_bb_bb(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Accumulates the unweighted context independent two body

interaction energies of <pose> between the backbones of Residue <rsd1> and Residue <rsd2> into EnergyMap <emap>

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::eval_ci_2b_bb_bb(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_ci_2b_bb_sc(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Accumulates the unweighted short range context independent two

body interaction energies of <pose> between the backbone of Residue <rsd1> and the sidechain of Residue <rsd2> into EnergyMap <emap>

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::eval_ci_2b_bb_sc(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_ci_2b_sc_sc(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Accumulates the unweighted short range context dependent two body

interaction energies of <pose> between the sidechains of Residue <rsd1> and Residue <rsd2> into Energymap <emap>

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::eval_ci_2b_sc_sc(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_ci_intrares_energy(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Accumulates the unweighted intra-residue one body energies for all

context independent two body terms that define intra-residue energies of <pose> Residue <rsd> into EnergyMap <emap>

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::eval_ci_intrares_energy(const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_dof_derivative(self: pyrosetta.rosetta.core.scoring.ScoreFunction, dof_id: pyrosetta.rosetta.core.id.DOF_ID, torsion_id: core::id::TorsionID, pose: pyrosetta.rosetta.core.pose.Pose) → float

C++: core::scoring::ScoreFunction::eval_dof_derivative(const class core::id::DOF_ID &, const class core::id::TorsionID &, const class core::pose::Pose &) const –> double

eval_intrares_energy(self: pyrosetta.rosetta.core.scoring.ScoreFunction, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

Accumulates for rsd the unweighted intra-residue one body energies

for all context dependent and context independent two body terms that define intra-residue energies

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::eval_intrares_energy(const class core::conformation::Residue &, const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

eval_long_range_twobody_energies(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

eval_npd_atom_derivative(self: pyrosetta.rosetta.core.scoring.ScoreFunction, atom_id: pyrosetta.rosetta.core.id.AtomID, pose: pyrosetta.rosetta.core.pose.Pose, domain_map: ObjexxFCL::FArray1D<int>, F1: pyrosetta.rosetta.numeric.xyzVector_double_t, F2: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: core::scoring::ScoreFunction::eval_npd_atom_derivative(const class core::id::AtomID &, const class core::pose::Pose &, const class ObjexxFCL::FArray1D<int> &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

eval_onebody_energies(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

eval_twobody_neighbor_energies(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

evaluate_rotamer_background_energies(self: pyrosetta.rosetta.core.scoring.ScoreFunction, set1: pyrosetta.rosetta.core.conformation.RotamerSetBase, residue2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, energy_vector: pyrosetta.rosetta.utility.vector1_float) → None

C++: core::scoring::ScoreFunction::evaluate_rotamer_background_energies(const class core::conformation::RotamerSetBase &, const class core::conformation::Residue &, const class core::pose::Pose &, class utility::vector1<float, class std::allocator<float> > &) const –> void

evaluate_rotamer_intrares_energies(self: pyrosetta.rosetta.core.scoring.ScoreFunction, set: pyrosetta.rosetta.core.conformation.RotamerSetBase, pose: pyrosetta.rosetta.core.pose.Pose, energies: pyrosetta.rosetta.utility.vector1_float) → None

C++: core::scoring::ScoreFunction::evaluate_rotamer_intrares_energies(const class core::conformation::RotamerSetBase &, const class core::pose::Pose &, class utility::vector1<float, class std::allocator<float> > &) const –> void

evaluate_rotamer_intrares_energy_maps(self: pyrosetta.rosetta.core.scoring.ScoreFunction, set: pyrosetta.rosetta.core.conformation.RotamerSetBase, pose: pyrosetta.rosetta.core.pose.Pose, emaps: pyrosetta.rosetta.utility.vector1_core_scoring_EMapVector) → None

C++: core::scoring::ScoreFunction::evaluate_rotamer_intrares_energy_maps(const class core::conformation::RotamerSetBase &, const class core::pose::Pose &, class utility::vector1<class core::scoring::EMapVector, class std::allocator<class core::scoring::EMapVector> > &) const –> void

evaluate_rotamer_pair_energies(self: pyrosetta.rosetta.core.scoring.ScoreFunction, set1: pyrosetta.rosetta.core.conformation.RotamerSetBase, set2: pyrosetta.rosetta.core.conformation.RotamerSetBase, pose: pyrosetta.rosetta.core.pose.Pose, energy_table: ObjexxFCL::FArray2D<float>) → None

C++: core::scoring::ScoreFunction::evaluate_rotamer_pair_energies(const class core::conformation::RotamerSetBase &, const class core::conformation::RotamerSetBase &, const class core::pose::Pose &, class ObjexxFCL::FArray2D<float> &) const –> void

finalize_after_derivatives(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

get_name(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → str

C++: core::scoring::ScoreFunction::get_name() const –> std::string

get_nonzero_weighted_scoretypes(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

Returns a list of the ScoreTypes which are non-zero with

their current weights

example(s):

scorefxn.get_nonzero_weighted_scoretypes()

See also:

ScoreFunction ScoreFunction.get_weight ScoreFunction.set_weight ScoreFunction.weights ScoreType create_score_function name_from_score_type score_type_from_name

C++: core::scoring::ScoreFunction::get_nonzero_weighted_scoretypes() const –> class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> >

get_self_ptr(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → pyrosetta.rosetta.core.scoring.ScoreFunction

C++: core::scoring::ScoreFunction::get_self_ptr() –> class std::shared_ptr<class core::scoring::ScoreFunction>

get_sub_score(*args, **kwargs)

Overloaded function.

1. get_sub_score(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, residue_mask: pyrosetta.rosetta.utility.vector1_bool) -> float

Compute the score for subset of residues

C++: core::scoring::ScoreFunction::get_sub_score(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &) const –> double

2. get_sub_score(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, residue_mask: pyrosetta.rosetta.utility.vector1_bool, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

Compute the score for subset of residues

C++: core::scoring::ScoreFunction::get_sub_score(const class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, class core::scoring::EMapVector &) const –> void

3. get_sub_score(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, residue_mask: pyrosetta.rosetta.utility.vector1_bool) -> float

Compute the score for subset of residues

C++: core::scoring::ScoreFunction::get_sub_score(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &) const –> double

4. get_sub_score(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, residue_mask: pyrosetta.rosetta.utility.vector1_bool, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

Compute the score for subset of residues

C++: core::scoring::ScoreFunction::get_sub_score(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, class core::scoring::EMapVector &) const –> void

get_sub_score_exclude_res(*args, **kwargs)

Overloaded function.

1. get_sub_score_exclude_res(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, exclude_list: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

Compute the score for subset of residues

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

2. get_sub_score_exclude_res(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, exclude_list: pyrosetta.rosetta.utility.vector1_unsigned_long, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

Compute the score for subset of residues

C++: core::scoring::ScoreFunction::get_sub_score_exclude_res(const class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class core::scoring::EMapVector &) const –> void

3. get_sub_score_exclude_res(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, exclude_list: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

Compute the score for subset of residues

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

4. get_sub_score_exclude_res(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, exclude_list: pyrosetta.rosetta.utility.vector1_unsigned_long, emap: pyrosetta.rosetta.core.scoring.EMapVector) -> None

Compute the score for subset of residues

C++: core::scoring::ScoreFunction::get_sub_score_exclude_res(class core::pose::Pose &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class core::scoring::EMapVector &) const –> void

get_weight(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.rosetta.core.scoring.ScoreType) → float

Returns the weight for ScoreType <t>

examples(s):

scorefxn.get_weight(fa_sol)

See also:

ScoreFunction ScoreFunction.set_weight ScoreType create_score_function name_from_score_type score_type_from_name

C++: core::scoring::ScoreFunction::get_weight(const enum core::scoring::ScoreType &) const –> double

has_nonzero_weight(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.rosetta.core.scoring.ScoreType) → bool

Returns true if the ScoreType <t> has a non-zero weight

example(s):

scorefxn.has_nonzero_weight(fa_sol)

See also:

ScoreFunction ScoreFunction.get_weight ScoreFunction.has_zero_weight ScoreFunction.set_weight ScoreFunction.weights ScoreType create_score_function name_from_score_type score_type_from_name

C++: core::scoring::ScoreFunction::has_nonzero_weight(const enum core::scoring::ScoreType &) const –> bool

has_zero_weight(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.rosetta.core.scoring.ScoreType) → bool

Returns true if the ScoreType <t> has a weight of zero,

example(s):

scorefxn.has_zero_weight(fa_sol)

See also:

ScoreFunction ScoreFunction.get_weight ScoreFunction.has_nonzero_weight ScoreFunction.set_weight ScoreFunction.weights ScoreType create_score_function name_from_score_type score_type_from_name

C++: core::scoring::ScoreFunction::has_zero_weight(const enum core::scoring::ScoreType &) const –> bool

indicate_required_context_graphs(self: pyrosetta.rosetta.core.scoring.ScoreFunction, context_graphs_required: pyrosetta.rosetta.utility.vector1_bool) → None

find which context graphs the energy methods require

C++: core::scoring::ScoreFunction::indicate_required_context_graphs(class utility::vector1<bool, class std::allocator<bool> > &) const –> void

info(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → core::scoring::ScoreFunctionInfo

return an object to describe abstractly the methods contained in this

ScoreFunction so that class Energies can ensure that the ScoreFunction is properly evaluated (ie, no obsolete cashed data is used )

C++: core::scoring::ScoreFunction::info() const –> class std::shared_ptr<class core::scoring::ScoreFunctionInfo>

initialize_from_file(self: pyrosetta.rosetta.core.scoring.ScoreFunction, filename: str) → None

Resets everything before reading the <filename>

C++: core::scoring::ScoreFunction::initialize_from_file(const class std::basic_string<char> &) –> void

long_range_energies_begin(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::LongRangeTwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::LongRangeTwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::LongRangeTwoBodyEnergy const> > > >

C++: core::scoring::ScoreFunction::long_range_energies_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy> > > >

long_range_energies_end(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::LongRangeTwoBodyEnergy const> const*, std::vector<std::shared_ptr<core::scoring::methods::LongRangeTwoBodyEnergy const>, std::allocator<std::shared_ptr<core::scoring::methods::LongRangeTwoBodyEnergy const> > > >

C++: core::scoring::ScoreFunction::long_range_energies_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy> *, class std::vector<class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy>, class std::allocator<class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy> > > >

max_atomic_interaction_cutoff(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → float

Returns the largest atomic interaction cutoff required by the

EnergyMethods

C++: core::scoring::ScoreFunction::max_atomic_interaction_cutoff() const –> double

merge(self: pyrosetta.rosetta.core.scoring.ScoreFunction, scorefxn_to_be_merged: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

Merges in the weights of another score function

example(s):

scorefxn.merge(scorefxn2)

See also:

ScoreFunction ScoreFunction.weights Energies create_score_function

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

name(self: pyrosetta.rosetta.core.scoring.ScoreFunction, weights_tag: str) → None

Accumulates the unweighted one body energies of all context

independent one body energies for <pose> Residue <rsd> into EnergyMap <emap>

: EnergyMap is an EMapVector

C++: core::scoring::ScoreFunction::name(const class std::basic_string<char> &) –> void

perturb_weights(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

Randomly perturbs non-zero score function weights

C++: core::scoring::ScoreFunction::perturb_weights() –> void

prepare_rotamers_for_packing(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, set: pyrosetta.rosetta.core.conformation.RotamerSetBase) → None

Lets the scoring functions cache anything they need to rapidly

calculate rotamer pair energies used in packing (like a trie, e.g.)

C++: core::scoring::ScoreFunction::prepare_rotamers_for_packing(const class core::pose::Pose &, class core::conformation::RotamerSetBase &) const –> void

ready_for_nonideal_scoring(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → bool

C++: core::scoring::ScoreFunction::ready_for_nonideal_scoring() const –> bool

reinitialize_minnode_for_residue(self: pyrosetta.rosetta.core.scoring.ScoreFunction, min_node: core::scoring::MinimizationNode, rsd: pyrosetta.rosetta.core.conformation.Residue, res_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache, min_map: core::kinematics::MinimizerMapBase, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::ScoreFunction::reinitialize_minnode_for_residue(class core::scoring::MinimizationNode &, const class core::conformation::Residue &, class basic::datacache::BasicDataCache &, const class core::kinematics::MinimizerMapBase &, class core::pose::Pose &) const –> void

reset(*args, **kwargs)

Overloaded function.

1. reset(self: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

Resets the ScoreFunction to default values, reading from the global options collection

C++: core::scoring::ScoreFunction::reset() –> void

2. reset(self: pyrosetta.rosetta.core.scoring.ScoreFunction, options: pyrosetta.rosetta.utility.options.OptionCollection) -> None

Resets the ScoreFunction to default values, reading from a (possibly local) options collection

C++: core::scoring::ScoreFunction::reset(const class utility::options::OptionCollection &) –> void

reset_energy_methods(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: core::scoring::ScoreFunction::reset_energy_methods() –> void

score(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) → float

Scores the given <pose> using this ScoreFunction. Alters the

Energies object within <pose>, but does not alter this ScoreFunction

: Synonym for () operator. Makes code look a little nicer. Doesn’t

do anything but call () operator.

C++: core::scoring::ScoreFunction::score(class core::pose::Pose &) const –> double

score_by_scoretype(*args, **kwargs)

Overloaded function.

1. score_by_scoretype(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, t: pyrosetta.rosetta.core.scoring.ScoreType) -> float
2. score_by_scoretype(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, t: pyrosetta.rosetta.core.scoring.ScoreType, weighted: bool) -> float

Returns the score of the ScoreType <t>

C++: core::scoring::ScoreFunction::score_by_scoretype(class core::pose::Pose &, const enum core::scoring::ScoreType, const bool) const –> double

score_types_by_method_type(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.rosetta.core.scoring.methods.EnergyMethodType) → pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

C++: core::scoring::ScoreFunction::score_types_by_method_type(const enum core::scoring::methods::EnergyMethodType &) const –> const class utility::vector1<enum core::scoring::ScoreType, class std::allocator<enum core::scoring::ScoreType> > &

serialize_weights(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → str

Serializes the non-zero score function term weights

Format: { term : weight, … }

C++: core::scoring::ScoreFunction::serialize_weights() const –> std::string

set_energy_method_options(self: pyrosetta.rosetta.core.scoring.ScoreFunction, energy_method_options_in: core::scoring::methods::EnergyMethodOptions) → None

Sets the EnergyMethodOptions object contained in this ScoreFunction.

with appropriate update of all the energy methods.

C++: core::scoring::ScoreFunction::set_energy_method_options(const class core::scoring::methods::EnergyMethodOptions &) –> void

set_etable(self: pyrosetta.rosetta.core.scoring.ScoreFunction, etable_name: str) → None

Given a <filename> (represented by a std::string), set the

e_table for this ScoreFunction.

C++: core::scoring::ScoreFunction::set_etable(const class std::basic_string<char> &) –> void

set_method_weights(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.rosetta.core.scoring.ScoreType, wts: pyrosetta.rosetta.utility.vector1_double) → None

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

set_weight(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.rosetta.core.scoring.ScoreType, setting: float) → None

Sets the weight for ScoreType <t> to <setting>

example(s):

scorefxn.set_weight(fa_sol,.5)

See also:

ScoreFunction ScoreFunction.get_weight ScoreFunction.weights ScoreType create_score_function name_from_score_type score_type_from_name

C++: core::scoring::ScoreFunction::set_weight(const enum core::scoring::ScoreType &, const double &) –> void

set_weight_if_zero(self: pyrosetta.rosetta.core.scoring.ScoreFunction, t: pyrosetta.rosetta.core.scoring.ScoreType, setting: float) → None

Sets the weight for ScoreType <t> to <setting> if weight is originally zero

example(s):

scorefxn.set_weight_if_zero(fa_sol,.5)

See also:

ScoreFunction ScoreFunction.get_weight ScoreFunction.set_weight ScoreType create_score_function name_from_score_type score_type_from_name

C++: core::scoring::ScoreFunction::set_weight_if_zero(const enum core::scoring::ScoreType &, const double &) –> void

setup_for_derivatives(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

setup_for_lr2benmeth_minimization_for_respair(*args, **kwargs)

Overloaded function.

1. setup_for_lr2benmeth_minimization_for_respair(self: pyrosetta.rosetta.core.scoring.ScoreFunction, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, lr2benergy: core::scoring::methods::LongRangeTwoBodyEnergy, g: core::scoring::MinimizationGraph, min_map: core::kinematics::MinimizerMapBase, p: pyrosetta.rosetta.core.pose.Pose, res_moving_wrt_eachother: bool, accumulate_fixed_energies: bool, rni: core::scoring::ResidueNeighborConstIterator, fixed_energies: pyrosetta.rosetta.core.scoring.EMapVector) -> None
2. setup_for_lr2benmeth_minimization_for_respair(self: pyrosetta.rosetta.core.scoring.ScoreFunction, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, lr2benergy: core::scoring::methods::LongRangeTwoBodyEnergy, g: core::scoring::MinimizationGraph, min_map: core::kinematics::MinimizerMapBase, p: pyrosetta.rosetta.core.pose.Pose, res_moving_wrt_eachother: bool, accumulate_fixed_energies: bool, rni: core::scoring::ResidueNeighborConstIterator, fixed_energies: pyrosetta.rosetta.core.scoring.EMapVector, edge_weight: float) -> None
3. setup_for_lr2benmeth_minimization_for_respair(self: pyrosetta.rosetta.core.scoring.ScoreFunction, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, lr2benergy: core::scoring::methods::LongRangeTwoBodyEnergy, g: core::scoring::MinimizationGraph, min_map: core::kinematics::MinimizerMapBase, p: pyrosetta.rosetta.core.pose.Pose, res_moving_wrt_eachother: bool, accumulate_fixed_energies: bool, rni: core::scoring::ResidueNeighborConstIterator, fixed_energies: pyrosetta.rosetta.core.scoring.EMapVector, edge_weight: float, edge_dweight: float) -> None

Initialize an edge in the MinimizationGraph with a particular long-range two body

C++: core::scoring::ScoreFunction::setup_for_lr2benmeth_minimization_for_respair(const class core::conformation::Residue &, const class core::conformation::Residue &, class std::shared_ptr<const class core::scoring::methods::LongRangeTwoBodyEnergy>, class core::scoring::MinimizationGraph &, const class core::kinematics::MinimizerMapBase &, class core::pose::Pose &, const bool, bool, class std::shared_ptr<class core::scoring::ResidueNeighborConstIterator>, class core::scoring::EMapVector &, const double, const double) const –> void

setup_for_minimizing(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, min_map: core::kinematics::MinimizerMapBase) → None

Initializes a MinimizationGraph and caches it in

Energies object of <pose>

: for use during minimization

C++: core::scoring::ScoreFunction::setup_for_minimizing(class core::pose::Pose &, const class core::kinematics::MinimizerMapBase &) const –> void

setup_for_minimizing_for_node(self: pyrosetta.rosetta.core.scoring.ScoreFunction, min_node: core::scoring::MinimizationNode, rsd: pyrosetta.rosetta.core.conformation.Residue, res_data_cache: pyrosetta.rosetta.basic.datacache.BasicDataCache, min_map: core::kinematics::MinimizerMapBase, pose: pyrosetta.rosetta.core.pose.Pose, accumulate_fixed_energies: bool, fixed_energies: pyrosetta.rosetta.core.scoring.EMapVector) → None

Initialize a single node of a MinimizationGraph with the one-body and two-body

energy methods that are held within this ScoreFunction object.

C++: core::scoring::ScoreFunction::setup_for_minimizing_for_node(class core::scoring::MinimizationNode &, const class core::conformation::Residue &, class basic::datacache::BasicDataCache &, const class core::kinematics::MinimizerMapBase &, class core::pose::Pose &, bool, class core::scoring::EMapVector &) const –> void

setup_for_minimizing_sr2b_enmeths_for_minedge(*args, **kwargs)

Overloaded function.

1. setup_for_minimizing_sr2b_enmeths_for_minedge(self: pyrosetta.rosetta.core.scoring.ScoreFunction, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, min_edge: core::scoring::MinimizationEdge, min_map: core::kinematics::MinimizerMapBase, pose: pyrosetta.rosetta.core.pose.Pose, res_moving_wrt_eachother: bool, accumulate_fixed_energies: bool, energy_edge: core::scoring::EnergyEdge, fixed_energies: pyrosetta.rosetta.core.scoring.EMapVector) -> None
2. setup_for_minimizing_sr2b_enmeths_for_minedge(self: pyrosetta.rosetta.core.scoring.ScoreFunction, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, min_edge: core::scoring::MinimizationEdge, min_map: core::kinematics::MinimizerMapBase, pose: pyrosetta.rosetta.core.pose.Pose, res_moving_wrt_eachother: bool, accumulate_fixed_energies: bool, energy_edge: core::scoring::EnergyEdge, fixed_energies: pyrosetta.rosetta.core.scoring.EMapVector, edge_weight: float) -> None

Initialize a single MinimizationEdge for a particular part of residues, storing

sr2b energy method pointers on the edge for those sr2b energy methods in this ScoreFunction

C++: core::scoring::ScoreFunction::setup_for_minimizing_sr2b_enmeths_for_minedge(const class core::conformation::Residue &, const class core::conformation::Residue &, class core::scoring::MinimizationEdge &, const class core::kinematics::MinimizerMapBase &, class core::pose::Pose &, const bool, bool, const class core::scoring::EnergyEdge *, class core::scoring::EMapVector &, const double) const –> void

setup_for_packing(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, residues_repacking: pyrosetta.rosetta.utility.vector1_bool, residues_designing: pyrosetta.rosetta.utility.vector1_bool) → None

Lets the scoring functions cache anything they need to calculate

energies in a packing step (rotamer_trials or pack_rotamers)

: the Etable caches tries for each of the residues, the

hydrogen bond function caches backbone/backbone hydrogen bonds

C++: core::scoring::ScoreFunction::setup_for_packing(class core::pose::Pose &, const class utility::vector1<bool, class std::allocator<bool> > &, const class utility::vector1<bool, class std::allocator<bool> > &) const –> void

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) → None

For external scorers: Let the energy methods prepare for

evaluating their scores on a particular structure

: invoked during scoring.

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

show(*args, **kwargs)

Overloaded function.

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

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

2. show(self: pyrosetta.rosetta.core.scoring.ScoreFunction, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Scores <pose> and shows the raw and weighted scores for each

non-zero ScoreType

example(s):

scorefxn.show(pose)

See also:

ScoreFunction ScoreFunction.weights Energies create_score_function

C++: core::scoring::ScoreFunction::show(class std::basic_ostream<char> &, class core::pose::Pose &) const –> void

3. show(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose) -> None

Scores <pose> and shows the raw and weighted scores for each

non-zero ScoreType

: this function is mostly for convenience in PyRosetta

example(s):

scorefxn.show(pose)

See also:

ScoreFunction ScoreFunction.weights Energies create_score_function

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

show_additional(*args, **kwargs)

Overloaded function.

1. show_additional(self: pyrosetta.rosetta.core.scoring.ScoreFunction, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) -> None
2. show_additional(self: pyrosetta.rosetta.core.scoring.ScoreFunction, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose, verbose: bool) -> None

C++: core::scoring::ScoreFunction::show_additional(class std::basic_ostream<char> &, class core::pose::Pose &, bool) const –> void

show_line(self: pyrosetta.rosetta.core.scoring.ScoreFunction, out: pyrosetta.rosetta.std.ostream, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::ScoreFunction::show_line(class std::basic_ostream<char> &, const class core::pose::Pose &) const –> void

show_line_headers(self: pyrosetta.rosetta.core.scoring.ScoreFunction, out: pyrosetta.rosetta.std.ostream) → None

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

show_pretty(self: pyrosetta.rosetta.core.scoring.ScoreFunction, out: pyrosetta.rosetta.std.ostream) → None

similar output as show( ostream, pose ) but without the pose

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

update_residue_for_packing(self: pyrosetta.rosetta.core.scoring.ScoreFunction, pose: pyrosetta.rosetta.core.pose.Pose, resid: int) → None

If inside packing, the pose changes conformation, inform the

scoring functions that any data they have cached in the Energies object is out of date. In particular, this is to update the trie(s) during rotamer trials.

C++: core::scoring::ScoreFunction::update_residue_for_packing(class core::pose::Pose &, unsigned long) const –> void

weights(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → pyrosetta.rosetta.core.scoring.EMapVector

Returns an EnergyMap of the current set of weights

example(s):

scorefxn.weights()

See also:

ScoreFunction ScoreFunction.get_weight ScoreFunction.set_weight ScoreFunction.weights ScoreType create_score_function name_from_score_type score_type_from_name

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

whole_structure_types(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → pyrosetta.rosetta.utility.vector1_core_scoring_ScoreType

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

ws_methods_begin(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::WholeStructureEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::WholeStructureEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::WholeStructureEnergy> > > >

C++: core::scoring::ScoreFunction::ws_methods_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::WholeStructureEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::WholeStructureEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::WholeStructureEnergy> > > >

ws_methods_end(self: pyrosetta.rosetta.core.scoring.ScoreFunction) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::scoring::methods::WholeStructureEnergy> const*, std::vector<std::shared_ptr<core::scoring::methods::WholeStructureEnergy>, std::allocator<std::shared_ptr<core::scoring::methods::WholeStructureEnergy> > > >

C++: core::scoring::ScoreFunction::ws_methods_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::scoring::methods::WholeStructureEnergy> *, class std::vector<class std::shared_ptr<class core::scoring::methods::WholeStructureEnergy>, class std::allocator<class std::shared_ptr<class core::scoring::methods::WholeStructureEnergy> > > >

class pyrosetta.rosetta.core.scoring.ScoreFunctionFactory

Bases: pybind11_builtins.pybind11_object

A collection of functions for making a single score_function

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.ScoreFunctionFactory) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

create_score_function(*args, **kwargs)

Overloaded function.

1. create_score_function(weights_tag: str) -> pyrosetta.rosetta.core.scoring.ScoreFunction

Returns a ScoreFunction from the database weights file <weights_tag>

example(s):

scorefxn = create_score_function(‘standard’)

See also:

ScoreFunction ScoreFunction.show ScoreFunction.weights ScoreType

C++: core::scoring::ScoreFunctionFactory::create_score_function(const class std::basic_string<char> &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

2. create_score_function(options: pyrosetta.rosetta.utility.options.OptionCollection, weights_tag: str) -> pyrosetta.rosetta.core.scoring.ScoreFunction

C++: core::scoring::ScoreFunctionFactory::create_score_function(const class utility::options::OptionCollection &, const class std::basic_string<char> &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

3. create_score_function(weights_tag: str, patch_tag: str) -> pyrosetta.rosetta.core.scoring.ScoreFunction

Returns a ScoreFunction from the database weights file <weights_tag>

with the patch <patch_tag>

example(s): See also:

ScoreFunction ScoreFunction.show ScoreFunction.weights ScoreType

C++: core::scoring::ScoreFunctionFactory::create_score_function(const class std::basic_string<char> &, const class std::basic_string<char> &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

4. create_score_function(options: pyrosetta.rosetta.utility.options.OptionCollection, weights_tag: str, patch_tag: str) -> pyrosetta.rosetta.core.scoring.ScoreFunction

C++: core::scoring::ScoreFunctionFactory::create_score_function(const class utility::options::OptionCollection &, const class std::basic_string<char> &, const class std::basic_string<char> &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

5. create_score_function(weights_tag: str, patch_tags: pyrosetta.rosetta.utility.vector1_std_string) -> pyrosetta.rosetta.core.scoring.ScoreFunction

Returns a ScoreFunction from the database weights file <weights_tag> with patches in <patch_tags>

C++: core::scoring::ScoreFunctionFactory::create_score_function(const class std::basic_string<char> &, const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

6. create_score_function(options: pyrosetta.rosetta.utility.options.OptionCollection, weights_tag: str, patch_tags: pyrosetta.rosetta.utility.vector1_std_string) -> pyrosetta.rosetta.core.scoring.ScoreFunction

C++: core::scoring::ScoreFunctionFactory::create_score_function(const class utility::options::OptionCollection &, const class std::basic_string<char> &, const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> class std::shared_ptr<class core::scoring::ScoreFunction>

validate_beta(weights_tag: str, options: pyrosetta.rosetta.utility.options.OptionCollection) → bool

checks if the weights file is probably a beta_15 weights file

and if it is consistent with the options system. static because C++ says it has to be; public because unit test spiritually const but you can’t do that with static

C++: core::scoring::ScoreFunctionFactory::validate_beta(const class std::basic_string<char> &, const class utility::options::OptionCollection &) –> bool

validate_talaris(weights_tag: str, options: pyrosetta.rosetta.utility.options.OptionCollection) → bool

checks if the weights file is probably a talaris weights file

and if it is consistent with the options system. static because C++ says it has to be; public because unit test spiritually const but you can’t do that with static

C++: core::scoring::ScoreFunctionFactory::validate_talaris(const class std::basic_string<char> &, const class utility::options::OptionCollection &) –> bool

class pyrosetta.rosetta.core.scoring.ScoreFunctionInfo

Bases: pybind11_builtins.pybind11_object

This object is handed to the pose’s Energies object and stored along with the cached energies. It is used in the next scoring evaluation to decide whether it’s safe to reuse cached energies.

It must describe the kinds of context that the Energies object provides to the scoring function. If any scoring function requires a tenA neighbor graph, then that information is stored here. If a scoring function requires a different kind of neighborness graph (think centroid mode), then this class will indicate the kind of storage.

Finally, it must describe the maximum atom-to-atom distance cutoff that characterizes the energy function.

So all we need is a constructor and an operator==

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.ScoreFunctionInfo) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.ScoreFunctionInfo, arg0: pyrosetta.rosetta.core.scoring.ScoreFunctionInfo) -> None
3. __init__(self: pyrosetta.rosetta.core.scoring.ScoreFunctionInfo, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

initialize_from(self: pyrosetta.rosetta.core.scoring.ScoreFunctionInfo, scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

C++: core::scoring::ScoreFunctionInfo::initialize_from(const class core::scoring::ScoreFunction &) –> void

max_atomic_interaction_distance(self: pyrosetta.rosetta.core.scoring.ScoreFunctionInfo) → float

C++: core::scoring::ScoreFunctionInfo::max_atomic_interaction_distance() const –> double

max_context_neighbor_cutoff(self: pyrosetta.rosetta.core.scoring.ScoreFunctionInfo) → float

C++: core::scoring::ScoreFunctionInfo::max_context_neighbor_cutoff() const –> double

requires_context_graph(self: pyrosetta.rosetta.core.scoring.ScoreFunctionInfo, cgt: pyrosetta.rosetta.core.scoring.ContextGraphType) → bool

C++: core::scoring::ScoreFunctionInfo::requires_context_graph(enum core::scoring::ContextGraphType) const –> bool

scores_present(self: pyrosetta.rosetta.core.scoring.ScoreFunctionInfo) → pyrosetta.rosetta.core.scoring.EMapVector

C++: core::scoring::ScoreFunctionInfo::scores_present() const –> const class core::scoring::EMapVector &

class pyrosetta.rosetta.core.scoring.ScoreType

Bases: pybind11_builtins.pybind11_object

Type for looking up cached energies

I guess we could get rid of the fa_ prefix, except maybe for fa_pair, to distinguish from std::pair and the centroid pair score…

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__(*args, **kwargs)

Overloaded function.

1. __eq__(self: pyrosetta.rosetta.core.scoring.ScoreType, arg0: pyrosetta.rosetta.core.scoring.ScoreType) -> bool
2. __eq__(self: pyrosetta.rosetta.core.scoring.ScoreType, arg0: int) -> bool

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__getstate__(self: pyrosetta.rosetta.core.scoring.ScoreType) → tuple

__gt__

Return self>value.

__hash__(self: pyrosetta.rosetta.core.scoring.ScoreType) → int

__init__(self: pyrosetta.rosetta.core.scoring.ScoreType, arg0: int) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__int__(self: pyrosetta.rosetta.core.scoring.ScoreType) → int

__le__

Return self<=value.

__lt__

Return self<value.

__ne__(*args, **kwargs)

Overloaded function.

1. __ne__(self: pyrosetta.rosetta.core.scoring.ScoreType, arg0: pyrosetta.rosetta.core.scoring.ScoreType) -> bool
2. __ne__(self: pyrosetta.rosetta.core.scoring.ScoreType, arg0: int) -> bool

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__(self: pyrosetta.rosetta.core.scoring.ScoreType) → str

__setattr__

Implement setattr(self, name, value).

__setstate__(self: pyrosetta.rosetta.core.scoring.ScoreType, arg0: tuple) → None

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

class pyrosetta.rosetta.core.scoring.SecondaryStructurePotential

Bases: pybind11_builtins.pybind11_object

secondary structure scoring cut from classic rosetta structure.h/structure.cc

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.SecondaryStructurePotential) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.SecondaryStructurePotential, arg0: pyrosetta.rosetta.core.scoring.SecondaryStructurePotential) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

rsigma_dot_initializer(rsigma_dot: ObjexxFCL::FArray4D<double>) → None

C++: core::scoring::SecondaryStructurePotential::rsigma_dot_initializer(class ObjexxFCL::FArray4D<double> &) –> void

score(self: pyrosetta.rosetta.core.scoring.SecondaryStructurePotential, pose: pyrosetta.rosetta.core.pose.Pose, weights: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights, hs_score: float, ss_score: float, rsigma_score: float, sheet_score: float) → None

score secondary structure

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

setup_for_scoring(self: pyrosetta.rosetta.core.scoring.SecondaryStructurePotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::SecondaryStructurePotential::setup_for_scoring(class core::pose::Pose &) const –> void

class pyrosetta.rosetta.core.scoring.SecondaryStructureWeights

Bases: pybind11_builtins.pybind11_object

Holds weights and flags for configuring a SecondaryStructureEnergy evaluation

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights, arg0: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

copy assignment

C++: core::scoring::SecondaryStructureWeights::operator=(const class core::scoring::SecondaryStructureWeights &) –> class core::scoring::SecondaryStructureWeights &

get_antiparallel_weight(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights) → float

antiparallel strand weight

C++: core::scoring::SecondaryStructureWeights::get_antiparallel_weight() const –> const double &

get_handedness_score_flag(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights) → bool

using handedness score?

C++: core::scoring::SecondaryStructureWeights::get_handedness_score_flag() const –> const bool &

get_localstrandpair_penalty(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights) → float

local strand pair penalty

C++: core::scoring::SecondaryStructureWeights::get_localstrandpair_penalty() const –> const double &

get_max_strand_dist_cutoff(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights) → float

max strand distance cutoff

C++: core::scoring::SecondaryStructureWeights::get_max_strand_dist_cutoff() const –> const double &

get_parallel_weight(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights) → float

parallel strand weight

C++: core::scoring::SecondaryStructureWeights::get_parallel_weight() const –> const double &

get_seq_sep_scale(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights) → float

sequence separation scale

C++: core::scoring::SecondaryStructureWeights::get_seq_sep_scale() const –> const double &

get_ss_cutoff(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights) → int

C++: core::scoring::SecondaryStructureWeights::get_ss_cutoff() const –> int

get_ss_lowstrand(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights) → int

C++: core::scoring::SecondaryStructureWeights::get_ss_lowstrand() const –> int

get_strand_dist_cutoff(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights) → float

strand distance cutoff

C++: core::scoring::SecondaryStructureWeights::get_strand_dist_cutoff() const –> const double &

get_stretch_strand_dist_cutoff(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights) → bool

stretching the strand distance cutoff?

C++: core::scoring::SecondaryStructureWeights::get_stretch_strand_dist_cutoff() const –> const bool &

set_antiparallel_weight(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights, weight: float) → None

set antiparallel strand weight

C++: core::scoring::SecondaryStructureWeights::set_antiparallel_weight(const double &) –> void

set_handedness_score_flag(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights, flag: bool) → None

use the handedness score

C++: core::scoring::SecondaryStructureWeights::set_handedness_score_flag(const bool &) –> void

set_localstrandpair_penalty(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights, penalty: float) → None

set local strand pair penalty

C++: core::scoring::SecondaryStructureWeights::set_localstrandpair_penalty(const double &) –> void

set_max_strand_dist_cutoff(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights, cutoff: float) → None

set max strand distance cutoff

C++: core::scoring::SecondaryStructureWeights::set_max_strand_dist_cutoff(const double &) –> void

set_parallel_weight(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights, weight: float) → None

set parallel strand weight

C++: core::scoring::SecondaryStructureWeights::set_parallel_weight(const double &) –> void

set_seq_sep_scale(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights, scale: float) → None

set sequence separation scale

C++: core::scoring::SecondaryStructureWeights::set_seq_sep_scale(const double &) –> void

set_ss_cutoff(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights, setting: int) → None

C++: core::scoring::SecondaryStructureWeights::set_ss_cutoff(const int) –> void

set_ss_lowstrand(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights, setting: int) → None

C++: core::scoring::SecondaryStructureWeights::set_ss_lowstrand(const int) –> void

set_strand_dist_cutoff(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights, cutoff: float) → None

set strand distance cutoff

C++: core::scoring::SecondaryStructureWeights::set_strand_dist_cutoff(const double &) –> void

set_stretch_strand_dist_cutoff(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights, flag: bool) → None

stretch the strand distance cutoff

C++: core::scoring::SecondaryStructureWeights::set_stretch_strand_dist_cutoff(const bool &) –> void

setup_parallel_antiparallel_weights(*args, **kwargs)

Overloaded function.

1. setup_parallel_antiparallel_weights(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights) -> None
2. setup_parallel_antiparallel_weights(self: pyrosetta.rosetta.core.scoring.SecondaryStructureWeights, randomize_weights: bool) -> None

setup parallel/antiparallel weights according to scheme

C++: core::scoring::SecondaryStructureWeights::setup_parallel_antiparallel_weights(const bool &) –> void

class pyrosetta.rosetta.core.scoring.SmoothEnvPairPotential

Bases: pybind11_builtins.pybind11_object

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.SmoothEnvPairPotential) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.SmoothEnvPairPotential, : pyrosetta.rosetta.core.scoring.SmoothEnvPairPotential) → pyrosetta.rosetta.core.scoring.SmoothEnvPairPotential

C++: core::scoring::SmoothEnvPairPotential::operator=(const class core::scoring::SmoothEnvPairPotential &) –> class core::scoring::SmoothEnvPairPotential &

compute_centroid_environment(self: pyrosetta.rosetta.core.scoring.SmoothEnvPairPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::SmoothEnvPairPotential::compute_centroid_environment(class core::pose::Pose &) const –> void

compute_dcentroid_environment(self: pyrosetta.rosetta.core.scoring.SmoothEnvPairPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::SmoothEnvPairPotential::compute_dcentroid_environment(class core::pose::Pose &) const –> void

evaluate_env_and_cbeta_deriv(self: pyrosetta.rosetta.core.scoring.SmoothEnvPairPotential, pose: pyrosetta.rosetta.core.pose.Pose, rsd: pyrosetta.rosetta.core.conformation.Residue, d_env_score: pyrosetta.rosetta.numeric.xyzVector_double_t, d_cb_score6: pyrosetta.rosetta.numeric.xyzVector_double_t, d_cb_score12: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: core::scoring::SmoothEnvPairPotential::evaluate_env_and_cbeta_deriv(const class core::pose::Pose &, const class core::conformation::Residue &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

evaluate_env_and_cbeta_scores(self: pyrosetta.rosetta.core.scoring.SmoothEnvPairPotential, 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::SmoothEnvPairPotential::evaluate_env_and_cbeta_scores(const class core::pose::Pose &, const class core::conformation::Residue &, double &, double &, double &) const –> void

evaluate_pair_and_cenpack_deriv(self: pyrosetta.rosetta.core.scoring.SmoothEnvPairPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, cendist: float, d_pair: float, d_cenpack: float) → None

C++: core::scoring::SmoothEnvPairPotential::evaluate_pair_and_cenpack_deriv(const class core::conformation::Residue &, const class core::conformation::Residue &, const double, double &, double &) const –> void

evaluate_pair_and_cenpack_score(self: pyrosetta.rosetta.core.scoring.SmoothEnvPairPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, cendist: float, pair_contribution: float, cenpack_contribution: float) → None

C++: core::scoring::SmoothEnvPairPotential::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.SmoothEnvPairPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

class pyrosetta.rosetta.core.scoring.Strands

Bases: pybind11_builtins.pybind11_object

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.Strands) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.Strands, total_residue: int) -> None
3. __init__(self: pyrosetta.rosetta.core.scoring.Strands, arg0: pyrosetta.rosetta.core.scoring.Strands) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__(self: pyrosetta.rosetta.core.scoring.Strands) → str

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

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

copy assignment

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

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

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

resize(self: pyrosetta.rosetta.core.scoring.Strands, nres: int) → None

C++: core::scoring::Strands::resize(const unsigned long) –> void

class pyrosetta.rosetta.core.scoring.TMscoreStore

Bases: pybind11_builtins.pybind11_object

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.TMscoreStore) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

add_residue_dis(self: pyrosetta.rosetta.core.scoring.TMscoreStore, d0: float, dis: float) → None

C++: core::scoring::TMscoreStore::add_residue_dis(const double, const double) –> void

apply(self: pyrosetta.rosetta.core.scoring.TMscoreStore) → None

C++: core::scoring::TMscoreStore::apply() –> void

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

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

set_nseq(self: pyrosetta.rosetta.core.scoring.TMscoreStore, nseq: int) → None

C++: core::scoring::TMscoreStore::set_nseq(const unsigned long) –> void

update(self: pyrosetta.rosetta.core.scoring.TMscoreStore) → None

C++: core::scoring::TMscoreStore::update() –> void

class pyrosetta.rosetta.core.scoring.UnfoldedStatePotential

Bases: pybind11_builtins.pybind11_object

making this a separate class because it relies on a database file. rather than putting the code to read the database file in the energy method class, it seems like the design we’re following is to have a class like this one that reads the file and provides the lookup into the data structure holding the database information and a separate class for the energy method implementation.

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.UnfoldedStatePotential, filename: str) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.UnfoldedStatePotential, : pyrosetta.rosetta.core.scoring.UnfoldedStatePotential) → pyrosetta.rosetta.core.scoring.UnfoldedStatePotential

C++: core::scoring::UnfoldedStatePotential::operator=(const class core::scoring::UnfoldedStatePotential &) –> class core::scoring::UnfoldedStatePotential &

get_unfoled_potential_file_weights(self: pyrosetta.rosetta.core.scoring.UnfoldedStatePotential) → pyrosetta.rosetta.core.scoring.EMapVector

returns an emap of the energy method weights specfied in the unfolded energy file

C++: core::scoring::UnfoldedStatePotential::get_unfoled_potential_file_weights() const –> class core::scoring::EMapVector

pose_raw_unfolded_state_energymap(self: pyrosetta.rosetta.core.scoring.UnfoldedStatePotential, pose: pyrosetta.rosetta.core.pose.Pose, e: pyrosetta.rosetta.core.scoring.EMapVector) → None

returns the unweighted unfolded state energy for the whole pose as an emap (i.e. broken up by score type)

C++: core::scoring::UnfoldedStatePotential::pose_raw_unfolded_state_energymap(const class core::pose::Pose &, class core::scoring::EMapVector &) const –> void

raw_unfolded_state_energymap(self: pyrosetta.rosetta.core.scoring.UnfoldedStatePotential, aa_name3: str, e: pyrosetta.rosetta.core.scoring.EMapVector) → None

returns the database values for an aa in the unfolded state - these are unweighted values!

C++: core::scoring::UnfoldedStatePotential::raw_unfolded_state_energymap(const class std::basic_string<char> &, class core::scoring::EMapVector &) const –> void

class pyrosetta.rosetta.core.scoring.VdWTinkerPoseInfo

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.VdWTinkerPoseInfo) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.VdWTinkerPoseInfo, arg0: pyrosetta.rosetta.core.scoring.VdWTinkerPoseInfo) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.VdWTinkerPoseInfo, : pyrosetta.rosetta.core.scoring.VdWTinkerPoseInfo) → pyrosetta.rosetta.core.scoring.VdWTinkerPoseInfo

C++: core::scoring::VdWTinkerPoseInfo::operator=(const class core::scoring::VdWTinkerPoseInfo &) –> class core::scoring::VdWTinkerPoseInfo &

being_packed(self: pyrosetta.rosetta.core.scoring.VdWTinkerPoseInfo, seqpos: int) → bool

C++: core::scoring::VdWTinkerPoseInfo::being_packed(const unsigned long) const –> bool

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

C++: core::scoring::VdWTinkerPoseInfo::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.VdWTinkerPoseInfo, pose: pyrosetta.rosetta.core.pose.Pose) → None

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

placeholder_info(self: pyrosetta.rosetta.core.scoring.VdWTinkerPoseInfo, seqpos: int) → pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo

C++: core::scoring::VdWTinkerPoseInfo::placeholder_info(const unsigned long) const –> const class core::scoring::VdWTinkerResidueInfo &

placeholder_residue(self: pyrosetta.rosetta.core.scoring.VdWTinkerPoseInfo, seqpos: int) → pyrosetta.rosetta.core.conformation.Residue

C++: core::scoring::VdWTinkerPoseInfo::placeholder_residue(const unsigned long) const –> const class core::conformation::Residue &

residue_info(self: pyrosetta.rosetta.core.scoring.VdWTinkerPoseInfo, i: int) → pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo

C++: core::scoring::VdWTinkerPoseInfo::residue_info(const unsigned long) –> class core::scoring::VdWTinkerResidueInfo &

set_placeholder(self: pyrosetta.rosetta.core.scoring.VdWTinkerPoseInfo, i: int, rsd: pyrosetta.rosetta.core.conformation.Residue, info: pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo) → None

C++: core::scoring::VdWTinkerPoseInfo::set_placeholder(const unsigned long, class std::shared_ptr<class core::conformation::Residue>, class std::shared_ptr<class core::scoring::VdWTinkerResidueInfo>) –> void

set_repack_list(self: pyrosetta.rosetta.core.scoring.VdWTinkerPoseInfo, repacking_residues: pyrosetta.rosetta.utility.vector1_bool) → None

C++: core::scoring::VdWTinkerPoseInfo::set_repack_list(const class utility::vector1<bool, class std::allocator<bool> > &) –> void

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

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

class pyrosetta.rosetta.core.scoring.VdWTinkerPotential

Bases: pybind11_builtins.pybind11_object

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.VdWTinkerPotential) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.VdWTinkerPotential, arg0: pyrosetta.rosetta.core.scoring.VdWTinkerPotential) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

amoeba_type_lookup(self: pyrosetta.rosetta.core.scoring.VdWTinkerPotential, atomname: str, resname: str, variantname: str) → int

Look up Amoeba type by resname/atomname/variant name

C++: core::scoring::VdWTinkerPotential::amoeba_type_lookup(const class std::basic_string<char> &, const class std::basic_string<char> &, const class std::basic_string<char> &) const –> unsigned long

assign_all_amoeba_types(self: pyrosetta.rosetta.core.scoring.VdWTinkerPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

called prior to scoring, eg

C++: core::scoring::VdWTinkerPotential::assign_all_amoeba_types(class core::pose::Pose &) const –> void

assign_residue_amoeba_type(self: pyrosetta.rosetta.core.scoring.VdWTinkerPotential, rsd: pyrosetta.rosetta.core.conformation.Residue, mp: pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo) → None

called prior to scoring, eg

C++: core::scoring::VdWTinkerPotential::assign_residue_amoeba_type(const class core::conformation::Residue &, class core::scoring::VdWTinkerResidueInfo &) const –> void

eval_residue_pair_derivatives(self: pyrosetta.rosetta.core.scoring.VdWTinkerPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, mp1: pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo, mp2: pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo, pose: pyrosetta.rosetta.core.pose.Pose, factor: float, r1_atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair, r2_atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair) → None

C++: core::scoring::VdWTinkerPotential::eval_residue_pair_derivatives(const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::scoring::VdWTinkerResidueInfo &, const class core::scoring::VdWTinkerResidueInfo &, const class core::pose::Pose &, const double &, 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

get_res_res_vdw(self: pyrosetta.rosetta.core.scoring.VdWTinkerPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, mp1: pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo, rsd2: pyrosetta.rosetta.core.conformation.Residue, mp2: pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo) → float

C++: core::scoring::VdWTinkerPotential::get_res_res_vdw(const class core::conformation::Residue &, const class core::scoring::VdWTinkerResidueInfo &, const class core::conformation::Residue &, const class core::scoring::VdWTinkerResidueInfo &) const –> double

get_rotamers_vdw_info(self: pyrosetta.rosetta.core.scoring.VdWTinkerPotential, pose: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.conformation.RotamerSetBase) → None

Get the amoeba info for rotamers

C++: core::scoring::VdWTinkerPotential::get_rotamers_vdw_info(const class core::pose::Pose &, class core::conformation::RotamerSetBase &) const –> void

read_in_amoeba_parameters(self: pyrosetta.rosetta.core.scoring.VdWTinkerPotential) → None

read in parameters for amoeba and mappings between

Rosetta residues/atoms and Amoeba types

C++: core::scoring::VdWTinkerPotential::read_in_amoeba_parameters() –> void

read_in_vdw_tinker_parameters(self: pyrosetta.rosetta.core.scoring.VdWTinkerPotential) → None

read in vdw parameters for amoeba types

C++: core::scoring::VdWTinkerPotential::read_in_vdw_tinker_parameters() –> void

setup_for_packing(self: pyrosetta.rosetta.core.scoring.VdWTinkerPotential, pose: pyrosetta.rosetta.core.pose.Pose, repacking_residues: pyrosetta.rosetta.utility.vector1_bool) → None

C++: core::scoring::VdWTinkerPotential::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.VdWTinkerPotential, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::VdWTinkerPotential::setup_for_scoring(class core::pose::Pose &) const –> void

update_residue_for_packing(self: pyrosetta.rosetta.core.scoring.VdWTinkerPotential, pose: pyrosetta.rosetta.core.pose.Pose, seqpos: int) → None

C++: core::scoring::VdWTinkerPotential::update_residue_for_packing(class core::pose::Pose &, const unsigned long) const –> void

class pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo, rsd: pyrosetta.rosetta.core.conformation.Residue) -> None
3. __init__(self: pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo, arg0: pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo, : pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo) → pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo

C++: core::scoring::VdWTinkerResidueInfo::operator=(const class core::scoring::VdWTinkerResidueInfo &) –> class core::scoring::VdWTinkerResidueInfo &

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

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

copy_clone(self: pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo) → pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo

C++: core::scoring::VdWTinkerResidueInfo::copy_clone() const –> class std::shared_ptr<class core::scoring::VdWTinkerResidueInfo>

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.VdWTinkerResidueInfo, rsd: pyrosetta.rosetta.core.conformation.Residue) → None

C++: core::scoring::VdWTinkerResidueInfo::initialize(const class core::conformation::Residue &) –> void

nonconst_vdw_type(self: pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo, atm: int) → int

C++: core::scoring::VdWTinkerResidueInfo::nonconst_vdw_type(const unsigned long) –> unsigned long &

vdw_type(self: pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo, atm: int) → int

C++: core::scoring::VdWTinkerResidueInfo::vdw_type(const unsigned long) const –> unsigned long

class pyrosetta.rosetta.core.scoring.VdWTinkerRotamerSetInfo

Bases: pyrosetta.rosetta.basic.datacache.CacheableData

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: pyrosetta.rosetta.core.scoring.VdWTinkerRotamerSetInfo, arg0: pyrosetta.rosetta.core.scoring.VdWTinkerRotamerSetInfo) -> None
2. __init__(self: pyrosetta.rosetta.core.scoring.VdWTinkerRotamerSetInfo, rotamer_set: pyrosetta.rosetta.core.conformation.RotamerSetBase) -> None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.VdWTinkerRotamerSetInfo, : pyrosetta.rosetta.core.scoring.VdWTinkerRotamerSetInfo) → pyrosetta.rosetta.core.scoring.VdWTinkerRotamerSetInfo

C++: core::scoring::VdWTinkerRotamerSetInfo::operator=(const class core::scoring::VdWTinkerRotamerSetInfo &) –> class core::scoring::VdWTinkerRotamerSetInfo &

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

C++: core::scoring::VdWTinkerRotamerSetInfo::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.VdWTinkerRotamerSetInfo, rotamer_set: pyrosetta.rosetta.core.conformation.RotamerSetBase) → None

dont forget to 0 the born_radii

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

residue_info(self: pyrosetta.rosetta.core.scoring.VdWTinkerRotamerSetInfo, i: int) → pyrosetta.rosetta.core.scoring.VdWTinkerResidueInfo

C++: core::scoring::VdWTinkerRotamerSetInfo::residue_info(const unsigned long) –> class core::scoring::VdWTinkerResidueInfo &

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

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

class pyrosetta.rosetta.core.scoring.WaterAdductHBondPotential

Bases: pybind11_builtins.pybind11_object

__delattr__

Implement delattr(self, name).

__dir__() → list

default dir() implementation

__eq__

Return self==value.

__format__()

default object formatter

__ge__

Return self>=value.

__getattribute__

Return getattr(self, name).

__gt__

Return self>value.

__hash__

Return hash(self).

__init__(self: pyrosetta.rosetta.core.scoring.WaterAdductHBondPotential) → None

__init_subclass__()

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__le__

Return self<=value.

__lt__

Return self<value.

__ne__

Return self!=value.

__new__()

Create and return a new object. See help(type) for accurate signature.

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

Return repr(self).

__setattr__

Implement setattr(self, name, value).

__sizeof__() → int

size of object in memory, in bytes

__str__

Return str(self).

__subclasshook__()

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

assign(self: pyrosetta.rosetta.core.scoring.WaterAdductHBondPotential, : pyrosetta.rosetta.core.scoring.WaterAdductHBondPotential) → pyrosetta.rosetta.core.scoring.WaterAdductHBondPotential

C++: core::scoring::WaterAdductHBondPotential::operator=(const class core::scoring::WaterAdductHBondPotential &) –> class core::scoring::WaterAdductHBondPotential &

fill_h2o_hbond_set(self: pyrosetta.rosetta.core.scoring.WaterAdductHBondPotential, pose: pyrosetta.rosetta.core.pose.Pose, hbond_set: pyrosetta.rosetta.core.scoring.hbonds.HBondSet) → None

Fills the hbond set with hydrogen bonds to water; clears the original hbonds in the set

and also resets the hbond_options in the input hbond set.

C++: core::scoring::WaterAdductHBondPotential::fill_h2o_hbond_set(const class core::pose::Pose &, class core::scoring::hbonds::HBondSet &) const –> void

get_residue_residue_h2o_hbonds_1way(self: pyrosetta.rosetta.core.scoring.WaterAdductHBondPotential, don_rsd: pyrosetta.rosetta.core.conformation.Residue, acc_rsd: pyrosetta.rosetta.core.conformation.Residue, don_nb: int, acc_nb: int, hbond_set: pyrosetta.rosetta.core.scoring.hbonds.HBondSet) → None

C++: core::scoring::WaterAdductHBondPotential::get_residue_residue_h2o_hbonds_1way(const class core::conformation::Residue &, const class core::conformation::Residue &, const int &, const int &, class core::scoring::hbonds::HBondSet &) const –> void

h2o_hbond_score_1way(self: pyrosetta.rosetta.core.scoring.WaterAdductHBondPotential, h2o_rsd: pyrosetta.rosetta.core.conformation.Residue, other_rsd: pyrosetta.rosetta.core.conformation.Residue) → float

C++: core::scoring::WaterAdductHBondPotential::h2o_hbond_score_1way(const class core::conformation::Residue &, const class core::conformation::Residue &) const –> double

water_adduct_hbond_score(self: pyrosetta.rosetta.core.scoring.WaterAdductHBondPotential, rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue) → float

C++: core::scoring::WaterAdductHBondPotential::water_adduct_hbond_score(const class core::conformation::Residue &, const class core::conformation::Residue &) const –> double

pyrosetta.rosetta.core.scoring.all_atom_rmsd(*args, **kwargs)

Overloaded function.

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

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

2. all_atom_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::all_atom_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.all_atom_rmsd_nosuper(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) → float

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

pyrosetta.rosetta.core.scoring.all_scatom_rmsd_nosuper(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) → float

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

pyrosetta.rosetta.core.scoring.apply_set_weights(scorefxn: pyrosetta.rosetta.core.scoring.ScoreFunction, settings: pyrosetta.rosetta.utility.vector1_std_string) → None

C++: core::scoring::apply_set_weights(class std::shared_ptr<class core::scoring::ScoreFunction>, const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> void

pyrosetta.rosetta.core.scoring.automorphic_rmsd(rsd1: pyrosetta.rosetta.core.conformation.Residue, rsd2: pyrosetta.rosetta.core.conformation.Residue, superimpose: bool) → float

RMSD between residues, accounting for automorphisms

(symmetries). For example if you have something like a tyrosine, you won’t get a higher rmsd just because you flipped the ring 180 degrees (Rocco). Does NOT include H atoms – they add lots of extra symmetries.

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

pyrosetta.rosetta.core.scoring.bb_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) → float

Compute rmsd for only backbone residues (excluding carboxyl oxygen)

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

pyrosetta.rosetta.core.scoring.bb_rmsd_including_O(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) → float

Compute rmsd for only backbone residues (including carboxyl oxygen)

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

pyrosetta.rosetta.core.scoring.calc_per_atom_sasa(*args, **kwargs)

Overloaded function.

1. calc_per_atom_sasa(pose: pyrosetta.rosetta.core.pose.Pose, atom_sasa: pyrosetta.rosetta.core.id.AtomID_Map_double_t, rsd_sasa: pyrosetta.rosetta.utility.vector1_double, probe_radius: float) -> float
2. calc_per_atom_sasa(pose: pyrosetta.rosetta.core.pose.Pose, atom_sasa: pyrosetta.rosetta.core.id.AtomID_Map_double_t, rsd_sasa: pyrosetta.rosetta.utility.vector1_double, probe_radius: float, use_big_polar_H: bool) -> float

Return total SASA

C++: core::scoring::calc_per_atom_sasa(const class core::pose::Pose &, class core::id::AtomID_Map<double> &, class utility::vector1<double, class std::allocator<double> > &, const double, const bool) –> double

3. calc_per_atom_sasa(pose: pyrosetta.rosetta.core.pose.Pose, atom_sasa: pyrosetta.rosetta.core.id.AtomID_Map_double_t, rsd_sasa: pyrosetta.rosetta.utility.vector1_double, probe_radius: float, use_big_polar_H: bool, atom_subset: pyrosetta.rosetta.core.id.AtomID_Map_bool_t) -> float
4. calc_per_atom_sasa(pose: pyrosetta.rosetta.core.pose.Pose, atom_sasa: pyrosetta.rosetta.core.id.AtomID_Map_double_t, rsd_sasa: pyrosetta.rosetta.utility.vector1_double, probe_radius: float, use_big_polar_H: bool, atom_subset: pyrosetta.rosetta.core.id.AtomID_Map_bool_t, use_naccess_sasa_radii: bool) -> float
5. calc_per_atom_sasa(pose: pyrosetta.rosetta.core.pose.Pose, atom_sasa: pyrosetta.rosetta.core.id.AtomID_Map_double_t, rsd_sasa: pyrosetta.rosetta.utility.vector1_double, probe_radius: float, use_big_polar_H: bool, atom_subset: pyrosetta.rosetta.core.id.AtomID_Map_bool_t, use_naccess_sasa_radii: bool, expand_polar_radii: bool) -> float
6. calc_per_atom_sasa(pose: pyrosetta.rosetta.core.pose.Pose, atom_sasa: pyrosetta.rosetta.core.id.AtomID_Map_double_t, rsd_sasa: pyrosetta.rosetta.utility.vector1_double, probe_radius: float, use_big_polar_H: bool, atom_subset: pyrosetta.rosetta.core.id.AtomID_Map_bool_t, use_naccess_sasa_radii: bool, expand_polar_radii: bool, polar_expansion_radius: float) -> float
7. calc_per_atom_sasa(pose: pyrosetta.rosetta.core.pose.Pose, atom_sasa: pyrosetta.rosetta.core.id.AtomID_Map_double_t, rsd_sasa: pyrosetta.rosetta.utility.vector1_double, probe_radius: float, use_big_polar_H: bool, atom_subset: pyrosetta.rosetta.core.id.AtomID_Map_bool_t, use_naccess_sasa_radii: bool, expand_polar_radii: bool, polar_expansion_radius: float, include_probe_radius_in_atom_radii: bool) -> float
8. calc_per_atom_sasa(pose: pyrosetta.rosetta.core.pose.Pose, atom_sasa: pyrosetta.rosetta.core.id.AtomID_Map_double_t, rsd_sasa: pyrosetta.rosetta.utility.vector1_double, probe_radius: float, use_big_polar_H: bool, atom_subset: pyrosetta.rosetta.core.id.AtomID_Map_bool_t, use_naccess_sasa_radii: bool, expand_polar_radii: bool, polar_expansion_radius: float, include_probe_radius_in_atom_radii: bool, use_lj_radii: bool) -> float

C++: core::scoring::calc_per_atom_sasa(const class core::pose::Pose &, class core::id::AtomID_Map<double> &, class utility::vector1<double, class std::allocator<double> > &, const double, const bool, class core::id::AtomID_Map<bool> &, const bool, const bool, const double, const bool, const bool) –> double

pyrosetta.rosetta.core.scoring.calc_per_atom_sasa_sc(pose: pyrosetta.rosetta.core.pose.Pose, rsd_sasa: pyrosetta.rosetta.utility.vector1_double, normalize: bool) → float

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

pyrosetta.rosetta.core.scoring.calc_per_res_hydrophobic_sasa(*args, **kwargs)

Overloaded function.

1. calc_per_res_hydrophobic_sasa(pose: pyrosetta.rosetta.core.pose.Pose, rsd_sasa: pyrosetta.rosetta.utility.vector1_double, rsd_hydrophobic_sasa: pyrosetta.rosetta.utility.vector1_double, probe_radius: float) -> float
2. calc_per_res_hydrophobic_sasa(pose: pyrosetta.rosetta.core.pose.Pose, rsd_sasa: pyrosetta.rosetta.utility.vector1_double, rsd_hydrophobic_sasa: pyrosetta.rosetta.utility.vector1_double, probe_radius: float, use_naccess_sasa_radii: bool) -> float

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

pyrosetta.rosetta.core.scoring.calc_total_sasa(pose: pyrosetta.rosetta.core.pose.Pose, probe_radius: float) → float

returns total sasa

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

pyrosetta.rosetta.core.scoring.calpha_superimpose_pose(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose) → float

Superimpose two poses by their calpha coordinates. Ignores residues

that do not have atoms named “CA.”

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

pyrosetta.rosetta.core.scoring.compute_bb_centroid(r1: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.numeric.xyzVector_double_t

Compute the average coordinate of the backbone heavy atoms

(aka center of mass).

C++: core::scoring::compute_bb_centroid(const class core::conformation::Residue &) –> class numeric::xyzVector<double>

pyrosetta.rosetta.core.scoring.compute_bb_radius(r1: pyrosetta.rosetta.core.conformation.Residue, r1bb_centroid: pyrosetta.rosetta.numeric.xyzVector_double_t) → float

Given a representative point for the center of the backbone,

compute the largest distance of all backbone heavy atoms to that point.

C++: core::scoring::compute_bb_radius(const class core::conformation::Residue &, const class numeric::xyzVector<double> &) –> double

pyrosetta.rosetta.core.scoring.compute_sc_centroid(r1: pyrosetta.rosetta.core.conformation.Residue) → pyrosetta.rosetta.numeric.xyzVector_double_t

Compute the average coordiante of the sidechain atoms, (aka center of mass)

or, if there are no side chain heavy atoms, compute the center of mass of the backbone.

C++: core::scoring::compute_sc_centroid(const class core::conformation::Residue &) –> class numeric::xyzVector<double>

pyrosetta.rosetta.core.scoring.compute_sc_radius(r1: pyrosetta.rosetta.core.conformation.Residue, r1sc_centroid: pyrosetta.rosetta.numeric.xyzVector_double_t) → float

Given a representative point for the center of the sidechain,

compute the largest distance of all sidechain heavy atoms to that point.

C++: core::scoring::compute_sc_radius(const class core::conformation::Residue &, const class numeric::xyzVector<double> &) –> double

pyrosetta.rosetta.core.scoring.create_shuffle_map_recursive_rms(sequence: pyrosetta.rosetta.std.vector_int, N: int, map: pyrosetta.rosetta.std.vector_std_vector_int_std_allocator_int_t) → None

C++: core::scoring::create_shuffle_map_recursive_rms(class std::vector<int, class std::allocator<int> >, const int, class std::vector<class std::vector<int, class std::allocator<int> >, class std::allocator<class std::vector<int, class std::allocator<int> > > > &) –> void

pyrosetta.rosetta.core.scoring.eval_atom_derivatives_for_minedge(min_edge: pyrosetta.rosetta.core.scoring.MinimizationEdge, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, res1_min_data: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, res2_min_data: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, pose: pyrosetta.rosetta.core.pose.Pose, respair_weights: pyrosetta.rosetta.core.scoring.EMapVector, r1atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair, r2atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair) → None

C++: core::scoring::eval_atom_derivatives_for_minedge(const class core::scoring::MinimizationEdge &, const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::scoring::ResSingleMinimizationData &, const class core::scoring::ResSingleMinimizationData &, const class core::pose::Pose &, 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> > &) –> void

pyrosetta.rosetta.core.scoring.eval_atom_derivatives_for_minnode(min_node: pyrosetta.rosetta.core.scoring.MinimizationNode, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, res_weights: pyrosetta.rosetta.core.scoring.EMapVector, atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair) → None

Evaluate the derivatives for all atoms on the input residue

for the terms that apply to this residue (which are stored on the input minimization node).

C++: core::scoring::eval_atom_derivatives_for_minnode(const class core::scoring::MinimizationNode &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::EMapVector &, class utility::vector1<class core::scoring::DerivVectorPair, class std::allocator<class core::scoring::DerivVectorPair> > &) –> void

pyrosetta.rosetta.core.scoring.eval_bbbb_sr2b_energies(r1: pyrosetta.rosetta.core.conformation.Residue, r2: pyrosetta.rosetta.core.conformation.Residue, r1bb_centroid: pyrosetta.rosetta.numeric.xyzVector_double_t, r2bb_centroid: pyrosetta.rosetta.numeric.xyzVector_double_t, r1bb_radius: float, r2bb_radius: float, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

With two bounding spheres for a pair of backbones,

evaluate all the backbone/sidechain energies. This will avoid a call to EnergyMethod E’s backbone_backbone_energiy method if either a) E’s atomic_interaction_cutoff + r1bb_radius + r2bb_radius < dist( r1bb_centroid, r2sc_centroid ) or b) E returns “false” in a call to its divides_backbone_and_- sidechain_energetics() method. The reason the call is avoided if “false” is returned is that, the entirety of a residue-pair-energy evaluation should be returned in the sidechain_sidechain_energy evaluation, if E does not implement its own versions of the bb/bb, bb/sc and sc/sc energy evaluation methods. Both context-dependent and context-independent 2-body energies are evaluated in this function.

C++: core::scoring::eval_bbbb_sr2b_energies(const class core::conformation::Residue &, const class core::conformation::Residue &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const double &, const double &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) –> void

pyrosetta.rosetta.core.scoring.eval_bbsc_sr2b_energies(r1: pyrosetta.rosetta.core.conformation.Residue, r2: pyrosetta.rosetta.core.conformation.Residue, r1bb_centroid: pyrosetta.rosetta.numeric.xyzVector_double_t, r2sc_centroid: pyrosetta.rosetta.numeric.xyzVector_double_t, r1bb_radius: float, r2sc_radius: float, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

With two bounding spheres for a backbone and a sidechain,

evaluate all the backbone/sidechain energies. This will avoid a call to EnergyMethod E’s backbone_sidechain_energiy method if either a) E’s atomic_interaction_cutoff + r1bb_radius + r2sc_radius < dist( r1bb_centroid, r2sc_centroid ) or b) E returns “false” in a call to its divides_backbone_and_- sidechain_energetics() method. The reason the call is avoided if “false” is returned is that, the entirety of a residue-pair-energy evaluation should be returned in the sidechain_sidechain_energy evaluation, if E does not implement its own versions of the bb/bb, bb/sc and sc/sc energy evaluation methods. Both context-dependent and context-independent 2-body energies are evaluated in this function.

C++: core::scoring::eval_bbsc_sr2b_energies(const class core::conformation::Residue &, const class core::conformation::Residue &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const double &, const double &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) –> void

pyrosetta.rosetta.core.scoring.eval_dof_deriv_for_minnode(min_node: pyrosetta.rosetta.core.scoring.MinimizationNode, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, dof_id: pyrosetta.rosetta.core.id.DOF_ID, torsion_id: pyrosetta.rosetta.core.id.TorsionID, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, weights: pyrosetta.rosetta.core.scoring.EMapVector) → float

C++: core::scoring::eval_dof_deriv_for_minnode(const class core::scoring::MinimizationNode &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::id::DOF_ID &, const class core::id::TorsionID &, const class core::scoring::ScoreFunction &, const class core::scoring::EMapVector &) –> double

pyrosetta.rosetta.core.scoring.eval_res_onebody_energies_for_minnode(min_node: pyrosetta.rosetta.core.scoring.MinimizationNode, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::eval_res_onebody_energies_for_minnode(const class core::scoring::MinimizationNode &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) –> void

pyrosetta.rosetta.core.scoring.eval_res_pair_energy_for_minedge(min_edge: pyrosetta.rosetta.core.scoring.MinimizationEdge, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::eval_res_pair_energy_for_minedge(const class core::scoring::MinimizationEdge &, const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) –> void

pyrosetta.rosetta.core.scoring.eval_scsc_sr2b_energies(r1: pyrosetta.rosetta.core.conformation.Residue, r2: pyrosetta.rosetta.core.conformation.Residue, r1sc_centroid: pyrosetta.rosetta.numeric.xyzVector_double_t, r2sc_centroid: pyrosetta.rosetta.numeric.xyzVector_double_t, r1sc_radius: float, r2sc_radius: float, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

With two bounding spheres for a pair of sidechains,

evaluate all the sidechain/sidechain energies. This will avoid a call to EnergyMethod E’s sidechain_sidechain_energiy method if a) E’s atomic_interaction_cutoff + r1sc_radius + r2sc_radius < dist( r1sc_centroid, r2sc_centroid ) and b) E returns “true” in a call to its divides_backbone_and_- sidechain_energetics() method. Both context-dependent and context-independent 2-body energies are evaluated in this function.

C++: core::scoring::eval_scsc_sr2b_energies(const class core::conformation::Residue &, const class core::conformation::Residue &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const double &, const double &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &) –> void

pyrosetta.rosetta.core.scoring.eval_weighted_atom_derivatives_for_minedge(min_edge: pyrosetta.rosetta.core.scoring.MinimizationEdge, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, res1_min_data: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, res2_min_data: pyrosetta.rosetta.core.scoring.ResSingleMinimizationData, pose: pyrosetta.rosetta.core.pose.Pose, respair_weights: pyrosetta.rosetta.core.scoring.EMapVector, r1atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair, r2atom_derivs: pyrosetta.rosetta.utility.vector1_core_scoring_DerivVectorPair) → None

C++: core::scoring::eval_weighted_atom_derivatives_for_minedge(const class core::scoring::MinimizationEdge &, const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::scoring::ResSingleMinimizationData &, const class core::scoring::ResSingleMinimizationData &, const class core::pose::Pose &, 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> > &) –> void

pyrosetta.rosetta.core.scoring.eval_weighted_dof_deriv_for_minnode(min_node: pyrosetta.rosetta.core.scoring.MinimizationNode, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, dof_id: pyrosetta.rosetta.core.id.DOF_ID, torsion_id: pyrosetta.rosetta.core.id.TorsionID, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, weights: pyrosetta.rosetta.core.scoring.EMapVector) → float

C++: core::scoring::eval_weighted_dof_deriv_for_minnode(const class core::scoring::MinimizationNode &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::id::DOF_ID &, const class core::id::TorsionID &, const class core::scoring::ScoreFunction &, const class core::scoring::EMapVector &) –> double

pyrosetta.rosetta.core.scoring.eval_weighted_res_onebody_energies_for_minnode(min_node: pyrosetta.rosetta.core.scoring.MinimizationNode, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector, scratch_emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::eval_weighted_res_onebody_energies_for_minnode(const class core::scoring::MinimizationNode &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &, class core::scoring::EMapVector &) –> void

pyrosetta.rosetta.core.scoring.eval_weighted_res_pair_energy_for_minedge(min_edge: pyrosetta.rosetta.core.scoring.MinimizationEdge, res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, sfxn: pyrosetta.rosetta.core.scoring.ScoreFunction, emap: pyrosetta.rosetta.core.scoring.EMapVector, scratch_emap: pyrosetta.rosetta.core.scoring.EMapVector) → None

C++: core::scoring::eval_weighted_res_pair_energy_for_minedge(const class core::scoring::MinimizationEdge &, const class core::conformation::Residue &, const class core::conformation::Residue &, const class core::pose::Pose &, const class core::scoring::ScoreFunction &, class core::scoring::EMapVector &, class core::scoring::EMapVector &) –> void

pyrosetta.rosetta.core.scoring.find_weights_file(*args, **kwargs)

Overloaded function.

1. find_weights_file(name: str) -> str
2. find_weights_file(name: str, extension: str) -> str

Utility function to locate a weights or patch file, either with a fully qualified path,

in the local directory, or in the database. Names may be passes either with or without the optional extension.

C++: core::scoring::find_weights_file(class std::basic_string<char>, class std::basic_string<char>) –> std::string

pyrosetta.rosetta.core.scoring.gdtha(ref: pyrosetta.rosetta.core.pose.Pose, model: pyrosetta.rosetta.core.pose.Pose, residues: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long) → float

Returns the average fraction of residues superimposable under a

series of distance thresholds– 0.5, 1.0, 2.0, and 4.0 Angstroms.

C++: core::scoring::gdtha(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

pyrosetta.rosetta.core.scoring.gdtsc(ref: pyrosetta.rosetta.core.pose.Pose, model: pyrosetta.rosetta.core.pose.Pose, residues: pyrosetta.rosetta.std.map_unsigned_long_unsigned_long) → float

Returns a single, Global Distance Test-like value that measures the

extent to which the functional ends of a model’s sidechains agree with their counterparts in a given reference structure.

Instead of comparing residue positions on the basis of CAs, gdtsc uses a characteristic atom near the end of each sidechain type for the evaluation of residue-residue distance deviations.

The traditional GDT score is a weighted sum of the fraction of residues superimposed within limits of 1, 2, 4, and 8Å. For gdtsc, the backbone superposition is used to calculate fractions of corresponding model-ref sidechain atom pairs that fit under 10 distance-limit values from 0.5A to 5A. Ambiguity in Asp or Glu terminal oxygen naming is not currently considered.

Reference: Keedy, DA. The other 90% of the protein. Proteins. 2009; 77 Suppl 9:29-49.

C++: core::scoring::gdtsc(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

pyrosetta.rosetta.core.scoring.get_angles() → ObjexxFCL::FArray2D<int>

C++: core::scoring::get_angles() –> const class ObjexxFCL::FArray2D<int> &

pyrosetta.rosetta.core.scoring.get_masks() → ObjexxFCL::FArray2D<ObjexxFCL::ubyte>

C++: core::scoring::get_masks() –> const class ObjexxFCL::FArray2D<class ObjexxFCL::ubyte> &

pyrosetta.rosetta.core.scoring.get_num_bytes() → int

C++: core::scoring::get_num_bytes() –> int

pyrosetta.rosetta.core.scoring.get_orientation(a_xyz: pyrosetta.rosetta.numeric.xyzVector_double_t, b_xyz: pyrosetta.rosetta.numeric.xyzVector_double_t, phi_index: int, theta_index: int, distance_ijxyz: float) → None

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

pyrosetta.rosetta.core.scoring.get_overlap(radius_a: float, radius_b: float, distance_ijxyz: float, degree_of_overlap: int) → None

C++: core::scoring::get_overlap(const double, const double, const double, int &) –> void

pyrosetta.rosetta.core.scoring.get_score_function(*args, **kwargs)

Overloaded function.

1. get_score_function() -> pyrosetta.rosetta.core.scoring.ScoreFunction
2. get_score_function(is_fullatom: bool) -> pyrosetta.rosetta.core.scoring.ScoreFunction

A helper function which returns a scoring function held in an owning pointer according to the

user’s command line parameters -score:weights and -score:patch By default it returns weights=talaris2013 for fullatom, and weights=cen_std and patch=”” for centroid

C++: core::scoring::get_score_function(const bool) –> class std::shared_ptr<class core::scoring::ScoreFunction>

3. get_score_function(options: pyrosetta.rosetta.utility.options.OptionCollection) -> pyrosetta.rosetta.core.scoring.ScoreFunction
4. get_score_function(options: pyrosetta.rosetta.utility.options.OptionCollection, is_fullatom: bool) -> pyrosetta.rosetta.core.scoring.ScoreFunction

A helper function which creates a scoring function held in an owning pointer reading

from the input OptionCollection

C++: core::scoring::get_score_function(const class utility::options::OptionCollection &, const bool) –> class std::shared_ptr<class core::scoring::ScoreFunction>

pyrosetta.rosetta.core.scoring.get_score_functionName(*args, **kwargs)

Overloaded function.

1. get_score_functionName() -> str
2. get_score_functionName(is_fullatom: bool) -> str

use the logic of get_score_function to get the name.

The name format is <weights_tag>[_<patch_tag> … ]

C++: core::scoring::get_score_functionName(const bool) –> std::string

pyrosetta.rosetta.core.scoring.get_score_function_legacy(*args, **kwargs)

Overloaded function.

1. get_score_function_legacy(pre_talaris_2013_weight_set: str) -> pyrosetta.rosetta.core.scoring.ScoreFunction
2. get_score_function_legacy(pre_talaris_2013_weight_set: str, pre_talaris_2013_patch_file: str) -> pyrosetta.rosetta.core.scoring.ScoreFunction

A helper function that either returns a ScoreFunctionOP created by get_score_function() or

the one specified by the protocol which is activated by the -restore_pre_talaris_2013_behavior flag. The purpose of this function is to preserve legacy behavior for the sake of reproducibility and so that a record of the old behavior is still preserved in the code to ease the process of reverting the change to get_score_function if that were the wrong behavior.

C++: core::scoring::get_score_function_legacy(class std::basic_string<char>, class std::basic_string<char>) –> class std::shared_ptr<class core::scoring::ScoreFunction>

3. get_score_function_legacy(options: pyrosetta.rosetta.utility.options.OptionCollection, pre_talaris_2013_weight_set: str) -> pyrosetta.rosetta.core.scoring.ScoreFunction
4. get_score_function_legacy(options: pyrosetta.rosetta.utility.options.OptionCollection, pre_talaris_2013_weight_set: str, pre_talaris_2013_patch_file: str) -> pyrosetta.rosetta.core.scoring.ScoreFunction

C++: core::scoring::get_score_function_legacy(const class utility::options::OptionCollection &, class std::basic_string<char>, class std::basic_string<char>) –> class std::shared_ptr<class core::scoring::ScoreFunction>

pyrosetta.rosetta.core.scoring.input_sasa_dats() → None

C++: core::scoring::input_sasa_dats() –> void

pyrosetta.rosetta.core.scoring.interpolate_value_and_deriv(potential: ObjexxFCL::FArray1D<double>, bin_width: float, r: float, value: float, deriv: float) → None

C++: core::scoring::interpolate_value_and_deriv(const class ObjexxFCL::FArray1D<double> &, const double &, const double &, double &, double &) –> void

pyrosetta.rosetta.core.scoring.invert_exclude_residues(*args, **kwargs)

Overloaded function.

1. invert_exclude_residues(nres: int, exclude_list: pyrosetta.rosetta.utility.vector1_int, : pyrosetta.rosetta.std.list_unsigned_long_t) -> None

C++: core::scoring::invert_exclude_residues(unsigned long, const class utility::vector1<int, class std::allocator<int> > &, class std::list<unsigned long, class std::allocator<unsigned long> > &) –> void

2. invert_exclude_residues(nres: int, exclude_list: pyrosetta.rosetta.utility.vector1_int) -> pyrosetta.rosetta.std.list_unsigned_long_t

C++: core::scoring::invert_exclude_residues(unsigned long, const class utility::vector1<int, class std::allocator<int> > &) –> class std::list<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.core.scoring.is_heavyatom(pose1: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

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

pyrosetta.rosetta.core.scoring.is_ligand_heavyatom(pose1: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

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

pyrosetta.rosetta.core.scoring.is_ligand_heavyatom_residues(residue1: pyrosetta.rosetta.core.conformation.Residue, : pyrosetta.rosetta.core.conformation.Residue, atomno: int) → bool

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

pyrosetta.rosetta.core.scoring.is_nbr_atom(pose1: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

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

pyrosetta.rosetta.core.scoring.is_non_peptide_heavy_atom(pose1: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

Return true if the pose residues and atoms specified are non-peptide heavy atoms.

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

pyrosetta.rosetta.core.scoring.is_polymer_heavyatom(pose1: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

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

pyrosetta.rosetta.core.scoring.is_protein_CA(pose1: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

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

pyrosetta.rosetta.core.scoring.is_protein_CA_or_CB(pose1: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

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

pyrosetta.rosetta.core.scoring.is_protein_CA_or_equiv(pose1: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

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

pyrosetta.rosetta.core.scoring.is_protein_backbone(pose1: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

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

pyrosetta.rosetta.core.scoring.is_protein_backbone_including_O(pose1: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

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

pyrosetta.rosetta.core.scoring.is_protein_sidechain_heavyatom(pose1: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

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

pyrosetta.rosetta.core.scoring.is_scatom(pose1: pyrosetta.rosetta.core.pose.Pose, : pyrosetta.rosetta.core.pose.Pose, resno: int, atomno: int) → bool

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

pyrosetta.rosetta.core.scoring.name_from_score_type(score_type: pyrosetta.rosetta.core.scoring.ScoreType) → str

Returns the name of the ScoreType <score_type>

example(s):

name_from_score_type(fa_sol)

See also:

ScoreFunction ScoreType Energies Energies.residue_total_energies score_type_from_name

C++: core::scoring::name_from_score_type(enum core::scoring::ScoreType) –> std::string

pyrosetta.rosetta.core.scoring.native_CA_gdtmm(native_pose: pyrosetta.rosetta.core.pose.Pose, pose: pyrosetta.rosetta.core.pose.Pose) → float

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

pyrosetta.rosetta.core.scoring.native_CA_rmsd(native_pose: pyrosetta.rosetta.core.pose.Pose, pose: pyrosetta.rosetta.core.pose.Pose) → float

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

pyrosetta.rosetta.core.scoring.nbr_atom_rmsd(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) → float

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

pyrosetta.rosetta.core.scoring.non_peptide_heavy_atom_RMSD(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose) → float

Return the RMSD of the non-peptide heavy atoms of two poses.

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

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

Add Non Const Membrane Embedding to the pose cache

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

pyrosetta.rosetta.core.scoring.nonconst_MembraneTopology_from_pose(pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.scoring.MembraneTopology

C++: core::scoring::nonconst_MembraneTopology_from_pose(class core::pose::Pose &) –> class core::scoring::MembraneTopology &

pyrosetta.rosetta.core.scoring.nonconst_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::nonconst_Membrane_FAEmbed_from_pose(class core::pose::Pose &) –> class core::scoring::Membrane_FAEmbed &

pyrosetta.rosetta.core.scoring.normalizing_area(res: str) → float

Get the area of the sidechain.

Threadsafe now, but these values are suspect.

C++: core::scoring::normalizing_area(const char) –> double

pyrosetta.rosetta.core.scoring.normalizing_area_total(res: str) → float

Given a one-letter code for a canonical amino acid, return

its total surface area.

Threadsafe now, but these values are suspect.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::normalizing_area_total(const char) –> double

pyrosetta.rosetta.core.scoring.normalizing_area_total_hydrophobic_atoms_only(res: str) → float

Given a one-letter code for a canonical amino acid, return

its total surface area, computed only using hydrophobic atoms.

Threadsafe now.

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::normalizing_area_total_hydrophobic_atoms_only(const char) –> double

pyrosetta.rosetta.core.scoring.normalizing_area_total_polar_atoms_only(res: str) → float

Given a one-letter code for a canonical amino acid, return

its total surface area, computed only using polar atoms.

Threadsafe. Based on Gabe Rocklin’s values (grocklin.com).

Vikram K. Mulligan (vmullig.edu).

C++: core::scoring::normalizing_area_total_polar_atoms_only(const char) –> double

pyrosetta.rosetta.core.scoring.residue_sc_rmsd_no_super(*args, **kwargs)

Overloaded function.

1. residue_sc_rmsd_no_super(res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue) -> float
2. residue_sc_rmsd_no_super(res1: pyrosetta.rosetta.core.conformation.Residue, res2: pyrosetta.rosetta.core.conformation.Residue, fxnal_group_only: bool) -> float

utility function to calculate per-residue sidechain rmsd without superposition

C++: core::scoring::residue_sc_rmsd_no_super(class std::shared_ptr<const class core::conformation::Residue>, class std::shared_ptr<const class core::conformation::Residue>, const bool) –> double

pyrosetta.rosetta.core.scoring.retrieve_CSA_from_pose(*args, **kwargs)

Overloaded function.

1. retrieve_CSA_from_pose(: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::ChemicalShiftAnisotropy

C++: core::scoring::retrieve_CSA_from_pose(class core::pose::Pose &) –> class std::shared_ptr<class core::scoring::ChemicalShiftAnisotropy>

2. retrieve_CSA_from_pose(: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::ChemicalShiftAnisotropy

C++: core::scoring::retrieve_CSA_from_pose(const class core::pose::Pose &) –> class std::shared_ptr<const class core::scoring::ChemicalShiftAnisotropy>

pyrosetta.rosetta.core.scoring.retrieve_DC_from_pose(*args, **kwargs)

Overloaded function.

1. retrieve_DC_from_pose(: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::DipolarCoupling

C++: core::scoring::retrieve_DC_from_pose(class core::pose::Pose &) –> class std::shared_ptr<class core::scoring::DipolarCoupling>

2. retrieve_DC_from_pose(: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::DipolarCoupling

C++: core::scoring::retrieve_DC_from_pose(const class core::pose::Pose &) –> class std::shared_ptr<const class core::scoring::DipolarCoupling>

pyrosetta.rosetta.core.scoring.retrieve_RDC_ROHL_from_pose(*args, **kwargs)

Overloaded function.

1. retrieve_RDC_ROHL_from_pose(: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::ResidualDipolarCoupling_Rohl

C++: core::scoring::retrieve_RDC_ROHL_from_pose(class core::pose::Pose &) –> class std::shared_ptr<class core::scoring::ResidualDipolarCoupling_Rohl>

2. retrieve_RDC_ROHL_from_pose(: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::ResidualDipolarCoupling_Rohl

C++: core::scoring::retrieve_RDC_ROHL_from_pose(const class core::pose::Pose &) –> class std::shared_ptr<const class core::scoring::ResidualDipolarCoupling_Rohl>

pyrosetta.rosetta.core.scoring.retrieve_RDC_from_pose(*args, **kwargs)

Overloaded function.

1. retrieve_RDC_from_pose(: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::ResidualDipolarCoupling

C++: core::scoring::retrieve_RDC_from_pose(class core::pose::Pose &) –> class std::shared_ptr<class core::scoring::ResidualDipolarCoupling>

2. retrieve_RDC_from_pose(: pyrosetta.rosetta.core.pose.Pose) -> core::scoring::ResidualDipolarCoupling

C++: core::scoring::retrieve_RDC_from_pose(const class core::pose::Pose &) –> class std::shared_ptr<const class core::scoring::ResidualDipolarCoupling>

pyrosetta.rosetta.core.scoring.rms_at_all_corresponding_atoms(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_id_map: pyrosetta.rosetta.std.map_core_id_AtomID_core_id_AtomID) → float

C++: core::scoring::rms_at_all_corresponding_atoms(const class core::pose::Pose &, const class core::pose::Pose &, const class std::map<class core::id::AtomID, class core::id::AtomID, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, class core::id::AtomID> > > &) –> double

pyrosetta.rosetta.core.scoring.rms_at_corresponding_atoms(*args, **kwargs)

Overloaded function.

1. rms_at_corresponding_atoms(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_id_map: pyrosetta.rosetta.std.map_core_id_AtomID_core_id_AtomID) -> float

C++: core::scoring::rms_at_corresponding_atoms(const class core::pose::Pose &, const class core::pose::Pose &, const class std::map<class core::id::AtomID, class core::id::AtomID, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, class core::id::AtomID> > > &) –> double

2. rms_at_corresponding_atoms(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_id_map: pyrosetta.rosetta.std.map_core_id_AtomID_core_id_AtomID, calc_rms_res: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

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

pyrosetta.rosetta.core.scoring.rms_at_corresponding_atoms_no_super(*args, **kwargs)

Overloaded function.

1. rms_at_corresponding_atoms_no_super(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_id_map: pyrosetta.rosetta.std.map_core_id_AtomID_core_id_AtomID) -> float

C++: core::scoring::rms_at_corresponding_atoms_no_super(const class core::pose::Pose &, const class core::pose::Pose &, const class std::map<class core::id::AtomID, class core::id::AtomID, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, class core::id::AtomID> > > &) –> double

2. rms_at_corresponding_atoms_no_super(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_id_map: pyrosetta.rosetta.std.map_core_id_AtomID_core_id_AtomID, calc_rms_res: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

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

pyrosetta.rosetta.core.scoring.rms_at_corresponding_heavy_atoms(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose) → float

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

pyrosetta.rosetta.core.scoring.score_type_from_name(name: str) → pyrosetta.rosetta.core.scoring.ScoreType

Returns the ScoreType titled <name>

example(s):

score_type_from_name(“fa_sol”)

See also:

ScoreFunction ScoreType Energies Energies.residue_total_energies name_from_score_type

C++: core::scoring::score_type_from_name(const class std::basic_string<char> &) –> enum core::scoring::ScoreType

pyrosetta.rosetta.core.scoring.setup_matching_CA_atoms(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, atom_id_map: pyrosetta.rosetta.std.map_core_id_AtomID_core_id_AtomID) → None

C++: core::scoring::setup_matching_CA_atoms(const class core::pose::Pose &, const class core::pose::Pose &, class std::map<class core::id::AtomID, class core::id::AtomID, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, class core::id::AtomID> > > &) –> void

pyrosetta.rosetta.core.scoring.setup_matching_atoms_with_given_names(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, atom_names_to_find: pyrosetta.rosetta.utility.vector1_std_string, atom_id_map: pyrosetta.rosetta.std.map_core_id_AtomID_core_id_AtomID) → None

C++: core::scoring::setup_matching_atoms_with_given_names(const class core::pose::Pose &, const class core::pose::Pose &, const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, class std::map<class core::id::AtomID, class core::id::AtomID, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, class core::id::AtomID> > > &) –> void

pyrosetta.rosetta.core.scoring.setup_matching_heavy_atoms(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, atom_id_map: pyrosetta.rosetta.std.map_core_id_AtomID_core_id_AtomID) → None

C++: core::scoring::setup_matching_heavy_atoms(const class core::pose::Pose &, const class core::pose::Pose &, class std::map<class core::id::AtomID, class core::id::AtomID, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, class core::id::AtomID> > > &) –> void

pyrosetta.rosetta.core.scoring.setup_matching_protein_backbone_heavy_atoms(pose1: pyrosetta.rosetta.core.pose.Pose, pose2: pyrosetta.rosetta.core.pose.Pose, atom_id_map: pyrosetta.rosetta.std.map_core_id_AtomID_core_id_AtomID) → None

C++: core::scoring::setup_matching_protein_backbone_heavy_atoms(const class core::pose::Pose &, const class core::pose::Pose &, class std::map<class core::id::AtomID, class core::id::AtomID, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, class core::id::AtomID> > > &) –> void

pyrosetta.rosetta.core.scoring.store_CSA_in_pose(: core::scoring::ChemicalShiftAnisotropy, : pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::store_CSA_in_pose(class std::shared_ptr<class core::scoring::ChemicalShiftAnisotropy>, class core::pose::Pose &) –> void

pyrosetta.rosetta.core.scoring.store_DC_in_pose(: core::scoring::DipolarCoupling, : pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::store_DC_in_pose(class std::shared_ptr<class core::scoring::DipolarCoupling>, class core::pose::Pose &) –> void

pyrosetta.rosetta.core.scoring.store_RDC_ROHL_in_pose(: core::scoring::ResidualDipolarCoupling_Rohl, : pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::store_RDC_ROHL_in_pose(class std::shared_ptr<class core::scoring::ResidualDipolarCoupling_Rohl>, class core::pose::Pose &) –> void

pyrosetta.rosetta.core.scoring.store_RDC_in_pose(: core::scoring::ResidualDipolarCoupling, : pyrosetta.rosetta.core.pose.Pose) → None

C++: core::scoring::store_RDC_in_pose(class std::shared_ptr<class core::scoring::ResidualDipolarCoupling>, class core::pose::Pose &) –> void

pyrosetta.rosetta.core.scoring.superimpose_pose(*args, **kwargs)

Overloaded function.

1. superimpose_pose(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.std.map_core_id_AtomID_core_id_AtomID) -> float
2. superimpose_pose(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.std.map_core_id_AtomID_core_id_AtomID, rms_calc_offset_val: float) -> float
3. superimpose_pose(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.std.map_core_id_AtomID_core_id_AtomID, rms_calc_offset_val: float, realign: bool) -> float

Superimpose mod_pose onto ref_pose using the mapping of atoms from

mod_pose to ref_pose given by map< AtomID, AtomID >

The rms_calc_offset_val is a small constant value used by the numerical machinery to ensure a nonzero determinant. This defaults to 1.0e-7. Realign determines whether this is subtracted off again (default false).

C++: core::scoring::superimpose_pose(class core::pose::Pose &, const class core::pose::Pose &, const class std::map<class core::id::AtomID, class core::id::AtomID, struct std::less<class core::id::AtomID>, class std::allocator<struct std::pair<const class core::id::AtomID, class core::id::AtomID> > > &, const double &, const bool) –> double

4. superimpose_pose(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t) -> float
5. superimpose_pose(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, rms_calc_offset_val: float) -> float
6. superimpose_pose(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.Pose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, rms_calc_offset_val: float, realign: bool) -> float

Superimpose mod_pose onto ref_pose using the mapping of atoms from

mod_pose to ref_pose given by atom_map

The rms_calc_offset_val is a small constant value used by the numerical machinery to ensure a nonzero determinant. This defaults to 1.0e-7. Realign determines whether this is subtracted off again (default false).

C++: core::scoring::superimpose_pose(class core::pose::Pose &, const class core::pose::Pose &, const class core::id::AtomID_Map<class core::id::AtomID> &, const double &, const bool) –> double

7. superimpose_pose(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.MiniPose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t) -> float
8. superimpose_pose(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.MiniPose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, rms_calc_offset_val: float) -> float
9. superimpose_pose(mod_pose: pyrosetta.rosetta.core.pose.Pose, ref_pose: pyrosetta.rosetta.core.pose.MiniPose, atom_map: pyrosetta.rosetta.core.id.AtomID_Map_core_id_AtomID_t, rms_calc_offset_val: float, realign: bool) -> float

Superimpose mod_pose onto ref_pose using the mapping of atoms from

mod_pose to ref_pose given by atom_map

The rms_calc_offset_val is a small constant value used by the numerical machinery to ensure a nonzero determinant. This defaults to 1.0e-7. Realign determines whether this is subtracted off again (default false).

C++: core::scoring::superimpose_pose(class core::pose::Pose &, const class core::pose::MiniPose &, const class core::id::AtomID_Map<class core::id::AtomID> &, const double &, const bool) –> double

pyrosetta.rosetta.core.scoring.xyz_gdtmm(*args, **kwargs)

Overloaded function.

1. xyz_gdtmm(p1a: ObjexxFCL::FArray2D<double>, p2a: ObjexxFCL::FArray2D<double>, m_1_1: float, m_2_2: float, m_3_3: float, m_4_3: float, m_7_4: float) -> float

Calculate gdtmm based on the given sets of xyz coordinates in p1a and p2a.

C++: core::scoring::xyz_gdtmm(class ObjexxFCL::FArray2D<double>, class ObjexxFCL::FArray2D<double>, double &, double &, double &, double &, double &) –> double

2. xyz_gdtmm(p1a: ObjexxFCL::FArray2D<double>, p2a: ObjexxFCL::FArray2D<double>) -> float

Calculate gdtmm based on the given sets of xyz coordinates in p1a and p2a.

C++: core::scoring::xyz_gdtmm(class ObjexxFCL::FArray2D<double>, class ObjexxFCL::FArray2D<double>) –> double

pyrosetta.rosetta.core.scoring.xyz_gdttm(p1a: ObjexxFCL::FArray2D<double>, p2a: ObjexxFCL::FArray2D<double>, gdttm_score: float, gdtha_score: float) → None

C++: core::scoring::xyz_gdttm(class ObjexxFCL::FArray2D<double>, class ObjexxFCL::FArray2D<double>, double &, double &) –> void

pyrosetta.rosetta.core.scoring.xyz_maxsub(p1a: ObjexxFCL::FArray2D<double>, p2a: ObjexxFCL::FArray2D<double>, natoms: int) → int

C++: core::scoring::xyz_maxsub(class ObjexxFCL::FArray2D<double>, class ObjexxFCL::FArray2D<double>, int) –> int